ib-extensions 1.2 → 1.3

data/lib/ib/models/account.rb

@@ -1,24 +1,24 @@
 module IB
 
-	class Account
-
-
-		def account_data_scan search_key, search_currency=nil
-			if account_values.is_a? Array
-				if search_currency.present?
-					account_values.find_all{|x| x.key.match( search_key )  && x.currency == search_currency.upcase }
-				else
-					account_values.find_all{|x| x.key.match( search_key ) }
-				end
-
-			else  # not tested!!
-				if search_currency.present?
-					account_values.where( ['key like %', search_key] ).where( currency: search_currency )
-				else  # any currency
-					account_values.where( ['key like %', search_key] )
-				end
-			end
-		end
+  class Account
+
+
+    def account_data_scan search_key, search_currency=nil
+      if account_values.is_a? Array
+        if search_currency.present?
+          account_values.find_all{|x| x.key.match( search_key )  && x.currency == search_currency.upcase }
+        else
+          account_values.find_all{|x| x.key.match( search_key ) }
+        end
+
+      else  # not tested!!
+        if search_currency.present?
+          account_values.where( ['key like %', search_key] ).where( currency: search_currency )
+        else  # any currency
+          account_values.where( ['key like %', search_key] )
+        end
+      end
+    end
 
 
 
@@ -33,31 +33,32 @@ Thus if several Orders are placed with the same order_ref, the active one is ret
 (If multible keys are specified, local_id preceeds perm_id)
 
 =end
-		def locate_order local_id: nil, perm_id: nil, order_ref: nil, status: /ubmitted/, contract: nil, con_id: nil
-			search_option = [ local_id.present? ? [:local_id , local_id] : nil ,
-										perm_id.present? ? [:perm_id, perm_id] : nil,
-										order_ref.present? ? [:order_ref , order_ref ] : nil ].compact.first
-			matched_items = if search_option.nil?
-												orders
-											else
-												orders.find_all{|x| x[search_option.first].to_i == search_option.last.to_i }
-											end
+	def locate_order local_id: nil, perm_id: nil, order_ref: nil, status: /ubmitted/, contract: nil, con_id: nil
+		search_option = [ local_id.present? ? [:local_id , local_id] : nil ,
+							perm_id.present? ? [:perm_id, perm_id] : nil,
+							order_ref.present? ? [:order_ref , order_ref ] : nil ].compact.first
+		matched_items = if search_option.nil?
+							orders
+						else
+							orders.find_all{|x| x[search_option.first].to_i == search_option.last.to_i }
+            end
+
       if contract.present?
-        if contract.con_id.nil? || contract.con_id =="" || contract.con_id.zero? 
-          contract =  contract.verify.first unless contract.is_a? IB::Bag
+        if contract.con_id.zero?  && !contract.is_a?( IB::Bag )
+          contract =  contract.verify.first
         end
         matched_items = matched_items.find_all{|o| o.contract.essential == contract.essential } 
       elsif con_id.present?
         matched_items = matched_items.find_all{|o| o.contract.con_id == con_id } 
       end
 
-			if status.present?
-				status = Regexp.new(status) unless status.is_a? Regexp
-				matched_items.detect{|x| x.order_state.status =~ status }
-			else
-				matched_items.last  # return the last item
-			end
-		end
+      if status.present?
+        status = Regexp.new(status) unless status.is_a? Regexp
+        matched_items.detect{|x| x.order_state.status =~ status }
+      else
+        matched_items.last  # return the last item
+      end
+    end
 
 
 =begin rdoc
@@ -74,10 +75,8 @@ convert_size: The action-attribute (:buy  :sell) is associated according the con
 
 The parameter «order» is modified!
 
-It can be used to modify and eventually cancel
+It can further used to modify and eventually cancel
 
-The method raises an  IB::TransmissionError if the transmitted order ist not acknowledged by the tws after
-one second.
 
 Example
 
@@ -85,111 +84,136 @@ Example
    order =  IB::Limit.order size: 100, price: 65.5
    g =  IB::Gateway.current.clients.last
 
-	 g.preview contract: j36, order: order
+   g.preview contract: j36, order: order
       => {:init_margin=>0.10864874e6,
-			    :maint_margin=>0.9704137e5,
-					:equity_with_loan=>0.97877973e6,
-					:commission=>0.524e1,
-					:commission_currency=>"USD",
-					:warning=>""}
+          :maint_margin=>0.9704137e5,
+          :equity_with_loan=>0.97877973e6,
+          :commission=>0.524e1,
+          :commission_currency=>"USD",
+          :warning=>""
 
    the_local_id = g.place order: order
-		  => 67						# returns local_id
-	 order.contract			# updated contract-record
-      => #<IB::Contract:0x00000000013c94b0 @attributes={:con_id=>95346693,
-			                                                   :exchange=>"SGX",
-																												 :right=>"",
-																												 :include_expired=>false}>
-
-		order.limit_price = 65   # set new price
-	  g.modify order: order    # and transmit
-		  => 67 # returns local_id
-
-		g.locate_order( local_id: the_local_id  )
-		  => returns the assigned order-record for inspection
-
-		g.cancel order: order
-				# logger output: 05:17:11 Cancelling 65 New #250/ from 3000/DU167349>
+      => 67						# returns local_id
+   order.contract			# updated contract-record
+
+      => #<IB::Contract:0x00000000013c94b0 @attributes={:con_id=>9534669, 
+                                                        :exchange=>"SGX",
+                                                        :right=>"",
+                                                        :include_expired=>false}>
+
+   order.limit_price = 65   # set new price
+   g.modify order: order    # and transmit
+     => 67 # returns local_id
+
+   g.locate_order( local_id: the_local_id  )
+     => returns the assigned order-record for inspection
+
+    g.cancel order: order
+    # logger output: 05:17:11 Cancelling 65 New #250/ from 3000/DU167349>
 =end
 
-		def place_order  order:, contract: nil, auto_adjust: true, convert_size:  false,  enable_error: false
-			# adjust the orderprice to  min-tick
-			result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
-			#·IB::Symbols are always qualified. They carry a description-field
-      qualified_contract = ->(c) { c.is_a?(IB::Contract) && ( c.description.present? || (c.con_id.present?  &&  !c.con_id.to_i.zero?) || (c.con_id.to_i <0  && c.sec_type == :bag )) }
-
-			order.contract ||=  if qualified_contract[ contract ]
-                        contract
-                         else
-                           contract.verify.first
-                         end
-
-      if order.contract.nil?
-       error "No valid contract given" if enable_error
-       return 0
-      end 
-			## sending of plain vanilla IB::Bags will fail using account.place, unless a (negative) con-id is provided!
-#			error "place order: ContractVerification failed. No con_id assigned"  unless qualified_contract[order.contract]
-			ib = IB::Connection.current
-			wrong_order = nil
-			the_local_id =  nil
-
-			### Handle Error messages
-			### Default action:  raise IB::Transmission Error
-			sa = ib.subscribe( :Alert ) do | msg |
-  #      puts "local_id: #{the_local_id}"
-				if msg.error_id == the_local_id
-				 if [ 110, #  The price does not confirm to the minimum price variation for this contract
-					   388,  # Order size x is smaller than the minimum required size of yy.
-					  ].include? msg.code
-           error msg.message if enable_error
-           wrong_order =  msg.error_id.to_i
-					 ib.logger.error msg.message
-				 end
-				end
-			end
-			order.account =  account  # assign the account_id to the account-field of IB::Order
-      self.orders.update_or_create order, :order_ref
-      order.auto_adjust # if auto_adjust  /defined in lib/order_handling
-			if convert_size
-				order.action = order.total_quantity.to_i > 0  ?	:buy : :sell
-        logger.info{ "Converted ordesize to #{order.total_quantity} and triggered a #{order.action}  order"} if  order.total_quantity.to_i < 0
-				order.total_quantity  = order.total_quantity.to_i.abs
-			end
-				# apply non_guarenteed and other stuff bound to the contract to order.
-			order.attributes.merge! order.contract.order_requirements unless order.contract.order_requirements.blank?
-				#  con_id and exchange fully qualify a contract, no need to transmit other data
-			the_contract = order.contract.con_id >0 ? Contract.new( con_id: order.contract.con_id, exchange: order.contract.exchange) : nil
-			the_local_id = order.place the_contract # return the local_id
-      i=0;	loop{i+=1; sleep(0.01); break if locate_order( local_id: the_local_id, status: nil ).present? || i> 1000  }
-
-			ib.unsubscribe sa
-      raise IB::TransmissionError," #{order.to_human} is not transmitted properly" if i >=1000
-      the_local_id  # return_value
-		end # place
-
-		# shortcut to enable
-		#  account.place order: {} , contract: {}
-		#  account.preview order: {} , contract: {}
-		#  account.modify order: {}
-		alias place place_order
+  def place_order  order:, contract: nil, auto_adjust: true, convert_size: true 
+    # adjust the orderprice to  min-tick
+    result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
+    #·IB::Symbols are always qualified. They carry a description-field
+    qualified_contract = ->(c) { c.is_a?(IB::Contract) && ( c.description.present? || !c.con_id.to_i.zero? || (c.con_id.to_i <0  && c.sec_type == :bag )) }
+
+    order.contract ||= if qualified_contract[ contract ]
+                         contract
+                       else
+                         contract.verify.first
+                       end
+
+    error "No valid contract given" unless order.contract.is_a?(IB::Contract)
+
+    ## sending of plain vanilla IB::Bags will fail using account.place, unless a (negative) con-id is provided!
+    error "place order: ContractVerification failed. No con_id assigned"  unless qualified_contract[order.contract]
+
+    ib = IB::Connection.current
+    wrong_order = nil
+    the_local_id =  nil
+    q =  Queue.new
+
+    ### Handle Error messages
+    ### Default action:  raise IB::Transmission Error
+    sa = ib.subscribe( :Alert ) do | msg |
+      #      puts "local_id: #{the_local_id}"a
+      puts msg.inspect
+      if msg.error_id == the_local_id
+        if [ 110, #  The price does not confirm to the minimum price variation for this contract
+            201, # Order rejected, No Trading permissions
+            203, # Security is not allowed for trading
+            325, # Disretionary Orders are not supported for ths combination of oerder-type and exchange
+            355, # Order size does not conform to market rule
+            361, 362, 363, 364, # invalid trigger or stop-price
+            388,  # Order size x is smaller than the minimum required size of yy.
+        ].include? msg.code
+          wrong_order =  msg.message
+          ib.logger.error msg.message
+          q.close   # closing the queue indicates that no order was transmitted
+        end
+      end
+    end
+    sb = ib.subscribe( :OpenOrder ){|m| q << m.order if m.order.local_id.to_i == the_local_id.to_i }
+    #  modify order (parameter) 
+    order.account =  account  # assign the account_id to the account-field of IB::Order
+    self.orders.update_or_create order, :order_ref
+    order.auto_adjust  if auto_adjust # /defined in  file order_handling.rb
+    if convert_size
+      order.action = order.total_quantity.to_i < 0 ? :sell : :buy unless order.action == :sell
+      logger.info{ "Converted ordesize to #{order.total_quantity} and triggered a #{order.action}  order"} if  order.total_quantity.to_i < 0
+      order.total_quantity  = order.total_quantity.to_i.abs
+    end
+    # apply non_guarenteed and other stuff bound to the contract to order.
+    order.attributes.merge! order.contract.order_requirements unless order.contract.order_requirements.blank?
+    #  con_id and exchange fully qualify a contract, no need to transmit other data
+    #  if no contract is passed to order.place, order.contract is used for placement
+    the_contract = order.contract.con_id.to_i >0 ? Contract.new( con_id: order.contract.con_id, exchange: order.contract.exchange) : nil
+    the_local_id = order.place the_contract # return the local_id
+    # if transmit is false, just include the local_id in the order-record
+    Thread.new{  if order.transmit  || order.what_if  then sleep 1 else sleep 0.001 end ;  q.close }
+    tws_answer = q.pop
+
+    ib.unsubscribe sa
+    ib.unsubscribe sb
+    if q.closed? 
+      if wrong_order.present?
+        raise IB::SymbolError,  wrong_order
+      elsif the_local_id.present?
+        order.local_id = the_local_id
+      else
+      error " #{order.to_human} is not transmitted properly", :symbol
+      end
+    else
+      order=tws_answer #  return order-record received from tws
+    end
+    the_local_id  # return_value
+  end # place
+
+
+  # shortcut to enable
+  #  account.place order: {} , contract: {}
+  #  account.preview order: {} , contract: {}
+  #  account.modify order: {}
+  alias place place_order
 
 =begin #rdoc
 Account#ModifyOrder operates in two modi:
 
 First: The order is specified  via local_id, perm_id or order_ref.
-	It is checked, whether the order is still modificable.
-	Then the Order ist provided through  the block. Any modification is done there.
-	Important: The Block has to return the modified IB::Order
+  It is checked, whether the order is still modificable.
+  Then the Order ist provided through  the block. Any modification is done there.
+  Important: The Block has to return the modified IB::Order
 
 Second: The order can be provided as parameter as well. This will be used
 without further checking. The block is now optional. 
-	Important: The OrderRecord must provide a valid Contract.
+  Important: The OrderRecord must provide a valid Contract.
 
 The simple version does not adjust the given prices to tick-limits.
 This has to be done manualy in the provided block
 =end
 
+
 		def modify_order  local_id: nil, order_ref: nil, order:nil
 
 			result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
@@ -213,19 +237,27 @@ This has to be done manualy in the provided block
 		#
 		# The order received from the TWS is kept in account.orders
 		#
-		# Raises IB::TransmissionError if the Order could not be placed properly
+		# Raises IB::SymbolError if the Order could not be placed properly
 		#
 	def preview order:, contract: nil, **args_which_are_ignored
 		# to_do:  use a copy of order instead of temporary setting order.what_if
-		result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
-		order.what_if = true
-		the_local_id = place_order order: order, contract: contract
-		i=0; loop{ i= i+1;  break if result[the_local_id] || i > 1000; sleep 0.01 }
-    raise IB::TransmissionError,"(Preview-) #{order.to_human} is not transmitted properly" if i >=1000
-		order.what_if = false # reset what_if flag
-		order.local_id = nil  # reset local_id to enable re-using the order-object for placing
-		result[the_local_id].order_state.forcast  #  return_value
-	end 
+    q =  Queue.new
+    ib =  IB::Connection.current
+    the_local_id = nil
+    req =  ib.subscribe( :OpenOrder ){|m| q << m.order if m.order.local_id.to_i == the_local_id.to_i }
+
+    result = ->(l){ orders.detect{|x| x.local_id == l  && x.submitted? } }
+    order.what_if = true
+    order.account = account
+    the_local_id = order.place  contract
+    Thread.new{  sleep 1  ;  q.close }
+    returned_order = q.pop
+    ib.unsubscribe req
+    order.what_if = false # reset what_if flag
+    order.local_id = nil  # reset local_id to enable re-using the order-object for placing
+    raise IB::SymbolError,"(Preview-) #{order.to_human} is not transmitted properly" if q.closed?
+    returned_order.order_state.forcast  #  return_value
+  end 
 
 # closes the contract by submitting an appropiate order
 	# the action- and total_amount attributes of the assigned order are overwritten.
@@ -254,12 +286,12 @@ This has to be done manualy in the provided block
 		error "Cannot transmit the order – No Contract given " unless order.contract.is_a?(IB::Contract)
 	
 		the_quantity = if reverse
-														 -contract_size[order.contract] * 2 
-													 elsif order.total_quantity.abs < 1 && !order.total_quantity.zero? 
-														-contract_size[order.contract] *  order.total_quantity.abs 
-													 else
-														 -contract_size[order.contract] 
-													 end
+						 -contract_size[order.contract] * 2 
+					 elsif order.total_quantity.abs < 1 && !order.total_quantity.zero? 
+						-contract_size[order.contract] *  order.total_quantity.abs 
+					 else
+						-contract_size[order.contract] 
+					 end
 		if the_quantity.zero?
 			logger.info{ "Cannot close #{order.contract.to_human} - no position detected"}
 		else
@@ -280,7 +312,7 @@ This has to be done manualy in the provided block
 	#
 	# Watchlist => [  contract => [ portfoliopositon] , ... ] ]
 	#
-		def organize_portfolio_positions   the_watchlists
+  def organize_portfolio_positions   the_watchlists= IB::Gateway.current.active_watchlists
 		  the_watchlists = [ the_watchlists ] unless the_watchlists.is_a?(Array)
 			self.focuses = portfolio_values.map do | pw |
 											z=	the_watchlists.map do | w |		
@@ -333,4 +365,5 @@ This has to be done manualy in the provided block
 #<PortfolioValue: DU167348 Pos=-3 @ 142.574;Value=-4277.22;PNL=-867.72 unrealized;<Option: ESTX50 20181221 put 3200.0  EUR>
 # => nil 
 #		# 
+
 end ## module 

data/lib/ib/models/bag.rb

@@ -0,0 +1,19 @@
+module IB
+  class Bag
+    def included_in? account
+      # iterate over combo-legs 
+      # and return the bag if all con_id's are present in the account.contracts-map
+      self if combo_legs.map do |c_l|
+        account.locate_contract c_l.con_id
+      end.count == combo_legs.count
+    end
+
+    # returns an array of portfolio-values 
+    #
+    def portfolio_value account
+      combo_legs.map do | c_l |
+        account.portfolio_values.detect{|x| x.contract.con_id ==  c_l.con_id}
+      end
+    end
+  end
+end

data/lib/ib/models/contract.rb

@@ -0,0 +1,16 @@
+
+module IB
+  class  Contract
+    def included_in? account
+      self if   account.locate_contract(con_id)
+    end
+
+    def portfolio_value account
+      if con_id.to_i > 0
+        account.portfolio_values.detect{|x| x.contract.con_id == con_id }
+      else
+        account.portfolio_values.detect{|x| x.contract == self }
+      end
+    end
+  end
+end

data/lib/ib/models/future.rb

@@ -0,0 +1,20 @@
+module IB
+  class Future
+    # helper method to roll an existing future
+    #
+    # Argument is the expiry of the target-future.
+    #
+
+    def roll **args
+      error "specify expiry to roll a future" if args.empty?
+      args[:to] = args[:expiry] if args[:expiry].present?  && args[:expiry] =~ /[mwMW]$/
+      args[:expiry]= IB::Spread.transform_distance( expiry, args.delete(:to  )) if args[:to].present?
+      
+      new_future =  merge( **args ).verify.first
+      error "Cannot roll future; target is no IB::Contract" unless new_future.is_a? IB::Future
+      target = IB::Spread.new exchange: exchange, symbol: symbol, currency: currency
+      target.add_leg self, action:  :buy
+      target.add_leg new_future, action: :sell
+    end
+  end
+end

data/lib/ib/models/option.rb

@@ -1,20 +1,27 @@
 module IB
   class Option
-    def roll expiry, strike
-      if strike.to_i > 2000
-        expiry, strike =  strike, expiry  # exchange values if input occurs in wrong direction
-      end
-      new_option =  Option.new( invariant_attributes.merge( con_id: nil, trading_class: '', last_trading_day: nil,
-                                                            local_symbol: "",
-                                                            expiry: expiry,  strike: strike ))
-      n_o = new_option.verify.first   # get con_id
+    # helper method to roll an existing option
+    #
+    # Arguments are strike and expiry of the target-option.
+    #
+    # Example:  ge= Symbols::Options.ge.verify.first.roll( strike: 13 )  
+    #           ge.to_human
+    #  => " added <Option: GE 20210917 call 7.0 SMART USD> added <Option: GE 20210917 call 13.0 SMART USD>" 
+# 
+    #   rolls the Option to another strike
 
+    def roll **args
+      error "specify strike and expiry to roll option" if args.empty?
+      args[:to] = args[:expiry] if args[:expiry].present?  && args[:expiry] =~ /[mwMW]$/
+      args[:expiry]= IB::Spread.transform_distance( expiry, args.delete(:to  )) if args[:to].present?
+      
+      new_option =  merge( **args ).verify.first
+      myself =  con_id.to_i.zero? ? self.verify.first  : self
+      error "Cannot roll option; target is no IB::Contract" unless new_option.is_a? IB::Option
+      error "Cannot roll option; Option cannot be verified" unless myself.is_a? IB::Option
       target = IB::Spread.new exchange: exchange, symbol: symbol, currency: currency
-      target.add_leg self, action:  :buy
-      target.add_leg n_o, action: :sell
-    rescue NoMethodError
-      Connection.logger.error "Rolling not possible. #{new_option.to_human} could not be verified"
-      nil
+      target.add_leg myself, action:  :buy
+      target.add_leg new_option, action: :sell
     end
   end
 end

data/lib/ib/option-chain.rb

@@ -1,9 +1,6 @@
 require 'ib/verify'
 require 'ib/market-price'
 module IB
-# define a custom ErrorClass which can be fired if a verification fails
-class VerifyError < StandardError
-end
 
 class Contract 
 
@@ -22,6 +19,8 @@ class Contract
   def option_chain ref_price: :request, right: :put, sort: :strike, exchange: '', trading_class: nil
 
     ib = Connection.current
+
+    # binary interthread communication
     finalize = Queue.new
 
     ## Enable Cashing of Definition-Matrix
@@ -61,7 +60,6 @@ class Contract
         sec_type: c[:sec_type]
 
       finalize.pop #  wait until data appeared 
-      #i=0; loop { sleep 0.1; break if i> 1000 || finalize; i+=1 } 
 
       ib.unsubscribe sub_sdop, sub_ocd
     else
@@ -131,8 +129,8 @@ class Contract
   end  # def
 
   # return a set of AtTheMoneyOptions
-  def atm_options ref_price: :request, right: :put
-    option_chain(  right: right, ref_price: ref_price, sort: :expiry) do | chain |
+  def atm_options ref_price: :request, right: :put, **params
+    option_chain(  right: right, ref_price: ref_price, sort: :expiry, **params) do | chain |
       chain[0]
     end
 

data/lib/ib/option-greeks.rb

@@ -1,29 +1,29 @@
 module IB
 
 
-	
  class Option
-# Ask for the Greeks and implied Vola 
-# 
+# Ask for the Greeks and implied Vola
+#
 # The result can be customized by a provided block.
-# 
-# 	IB::Symbols::Options.aapl.greeks{ |x| x }
-# 	-> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
-#  
+#
+#	IB::Symbols::Options.aapl.greeks{ |x| x }
+#	-> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
+#
 #   Possible values for Parameter :what --> :all :model, :bid, :ask, :bidask, :last
-# 
+#
 	 def request_greeks delayed:  true, what: :model, thread: false
 
 		 tws = Connection.current 		 # get the initialized ib-ruby instance
 		 # define requested tick-attributes
 		 request_data_type = IB::MARKET_DATA_TYPES.rassoc( delayed ? :frozen_delayed : :frozen ).first
 		 # possible types = 	[ [ :delayed_model_option , :model_option ] , [:delayed_last_option , :last_option ],
-		 # [ :delayed_bid_option , :bid_option ], [ :delayed_ask_option , :ask_option ]	]											  	        
+		 # [ :delayed_bid_option , :bid_option ], [ :delayed_ask_option , :ask_option ]]
 		 tws.send_message :RequestMarketDataType, :market_data_type =>  request_data_type
 		 tickdata = []
 
 		 self.greek = OptionDetail.new if greek.nil?
      greek.updated_at = Time.now
+     greek.option = self
      queue =  Queue.new
 
 		 #keep the method-call running until the request finished
@@ -32,9 +32,9 @@ module IB
 		 th = Thread.new do
 			 the_id  =  nil
 			 # subscribe to TickPrices
-       s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	queue.push(true) 	if msg.ticker_id == the_id  }
-       e_id = tws.subscribe(:Alert){|x| queue.push(false)  if [200,353].include?( x.code) && x.error_id == the_id } 
-       t_id = tws.subscribe( :TickSnapshotEnd, :TickPrice, :TickString, :TickSize, :TickGeneric, :MarketDataType  ) {|msg| msg }
+       s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	queue.push(true)	if msg.ticker_id == the_id  }
+       e_id = tws.subscribe(:Alert){|x| queue.push(false)  if [200,353].include?( x.code) && x.error_id == the_id }
+       t_id = tws.subscribe( :TickSnapshotEnd, :TickPrice, :TickString, :TickSize, :TickGeneric, :MarketDataType, :TickRequestParameters  ) {|msg| msg }
 			 # TWS Error 200: No security definition has been found for the request
 			 # TWS Error 354: Requested market data is not subscribed.
 
@@ -56,22 +56,28 @@ module IB
 						 (bf + msg.greeks.keys).each{ |a| greek.send( a.to_s+"=", msg.send( a)) }
 						 tickdata << msg  if [ :all, :model ].include?( what	)
 					 end
-           queue.push(true) if tickdata.is_a?(IB::Messages::Incoming::TickOption) || (tickdata.size == 2 && what== :bidask) || (tickdata.size == 4 && what == :all)
+           # fast entry abortion ---> daiabled for now
+         #  queue.push(true) if tickdata.is_a?(IB::Messages::Incoming::TickOption) || (tickdata.size == 2 && what== :bidask) || (tickdata.size == 4 && what == :all)
 				 end
 			 end  # if sub_id
 
 			 # initialize »the_id« that is used to identify the received tick messages
 			 # by firing the market data request
-			 the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true 
+       iji = 0
+       loop do
+         the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
 
-       result = queue.pop
-					 # reduce :close_price delayed_close  to close a.s.o 
-       if result == false
-         Connection.logger.info{ "#{to_human} --> No Marketdata received " } 
-       else
-         self.misc =  tickdata if thread  # store internally if in thread modus
+         result = queue.pop
+         # reduce :close_price delayed_close  to close a.s.o
+         if result == false
+           Connection.logger.info{ "#{to_human} --> No Marketdata received " }
+         else
+           self.misc =  tickdata if thread  # store internally if in thread modus
+         end
+         break if  !tickdata.empty?  ||  iji > 10
+         iji =  iji + 1
+         Connection.logger.info{ "OptionGreeks::#{to_human} --> delayed processing. Trying again (#{iji}) " }
        end
-
 			 tws.unsubscribe sub_id, s_id, e_id, t_id
 		 end  # thread
 		 if thread