ib-extensions 1.0 → 1.1

data/lib/ib/models/option.rb

@@ -0,0 +1,20 @@
+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
+
+      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
+    end
+  end
+end

data/lib/ib/option-chain.rb

@@ -8,188 +8,186 @@ end
 class Contract 
 
 
-	
-# returns the Option Chain of the contract (if available)
-#
-## parameters
-### right:: :call, :put, :straddle
-### ref_price::  :request or a numeric value
-### sort:: :strike, :expiry 
-### exchange:: List of Exchanges to be queried (Blank for all available Exchanges)
-		def option_chain ref_price: :request, right: :put, sort: :strike, exchange: ''
-
-			ib =  Connection.current
-
-			## Enable Cashing of Definition-Matrix
-			@option_chain_definition ||= [] 
-
-			my_req = nil; finalize= false
-			
-			# -----------------------------------------------------------------------------------------------------
-			# get OptionChainDefinition from IB ( instantiate cashed Hash )
-			if @option_chain_definition.blank?
-				sub_sdop = ib.subscribe( :SecurityDefinitionOptionParameterEnd ) { |msg| finalize = true if msg.request_id == my_req }
-				sub_ocd =  ib.subscribe( :OptionChainDefinition ) do | msg |
-					if msg.request_id == my_req
-						message =  msg.data
-						# transfer the first record to @option_chain_definition
-						if @option_chain_definition.blank?
-							@option_chain_definition =  msg.data
-
-						end
-						# override @option_chain_definition if a decent combination of attributes is met
-						# us- options:  use the smart dataset
-						# other options: prefer options of the default trading class 
-						if message[:exchange] == 'SMART'	
-							@option_chain_definition =  msg.data
-							finalize = true
-						end
-						if @option_chain_definition.blank? &&  message[:trading_class] == symbol 
-							@option_chain_definition =  msg.data
-						end
-					end
-				end
-
-				c = verify.first  #  ensure a complete set of attributes
-				my_req = ib.send_message :RequestOptionChainDefinition, con_id: c.con_id,
-					symbol: c.symbol,
-					exchange: c.sec_type == :future ? c.exchange : "", # BOX,CBOE',
-					sec_type: c[:sec_type]
-
-				Thread.new do  
-
-					Timeout::timeout(1, IB::TransmissionError,"OptionChainDefinition not received" ) do
-						loop{ sleep 0.1; break if finalize } 
-					end
-					ib.unsubscribe sub_sdop , sub_ocd
-				end.join
-		else
-			Connection.logger.error { "#{to_human} : using cached data" }
-		end
-
-		# -----------------------------------------------------------------------------------------------------
-		# select values and assign to options
-		#
-		unless @option_chain_definition.blank? 
-			requested_strikes =  if block_given?
-														 ref_price = market_price if ref_price == :request
-														 if ref_price.nil?
-															 ref_price =	 @option_chain_definition[:strikes].min  +
-																 ( @option_chain_definition[:strikes].max -  
-																	@option_chain_definition[:strikes].min ) / 2 
-																 Connection.logger.error{  "#{to_human} :: market price not set – using midpoint of available strikes instead: #{ref_price.to_f}" }
-														 end
-														 atm_strike = @option_chain_definition[:strikes].min_by { |x| (x - ref_price).abs }
-														 the_grouped_strikes = @option_chain_definition[:strikes].group_by{|e| e <=> atm_strike}	
-														 begin
-															 the_strikes =		yield the_grouped_strikes
-															 the_strikes.unshift atm_strike unless the_strikes.first == atm_strike	  # the first item is the atm-strike
-															 the_strikes
-														 rescue
-															 Connection.logger.error "#{to_human} :: not enough strikes :#{@option_chain_definition[:strikes].map(&:to_f).join(',')} "
-															 []
-														 end
-													 else
-														 @option_chain_definition[:strikes]
-													 end
-
-				# third Friday of a month
-				monthly_expirations =  @option_chain_definition[:expirations].find_all{|y| (15..21).include? y.day }
-#				puts @option_chain_definition.inspect
-				option_prototype = -> ( ltd, strike ) do 
-						IB::Option.new( symbol: symbol, 
-													 exchange: @option_chain_definition[:exchange],
-													 trading_class: @option_chain_definition[:trading_class],
-													 multiplier: @option_chain_definition[:multiplier],
-													 currency: currency,  
-													 last_trading_day: ltd, 
-													 strike: strike, 
-													 right: right )
-				end
-				options_by_expiry = -> ( schema ) do
-					# Array: [ yymm -> Options] prepares for the correct conversion to a Hash
-					Hash[  monthly_expirations.map do | l_t_d |
-						[  l_t_d.strftime('%y%m').to_i , schema.map{ | strike | option_prototype[ l_t_d, strike ]}.compact ]
-					end  ]                         # by Hash[ ]
-				end
-				options_by_strike = -> ( schema ) do
-					Hash[ schema.map do | strike |
-						[  strike ,   monthly_expirations.map{ | l_t_d | option_prototype[ l_t_d, strike ]}.compact ]
-					end  ]                         # by Hash[ ]
-				end
-
-				if sort == :strike
-					options_by_strike[ requested_strikes ] 
-				else 
-					options_by_expiry[ requested_strikes ] 
-				end
-			else
-				Connection.logger.error "#{to_human} ::No Options available"
-				nil # return_value
-			end
-		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 |
-								chain[0]
-			end
-
-				
-			end
-
-		# return   InTheMoneyOptions
-		def itm_options count:  5, right: :put, ref_price: :request, sort: :strike
-			option_chain(  right: right,  ref_price: ref_price, sort: sort ) do | chain |
-					if right == :put
-						above_market_price_strikes = chain[1][0..count-1]
-					else
-						below_market_price_strikes = chain[-1][-count..-1].reverse
-				end # branch
-			end
-		end		# def
-
-    # return OutOfTheMoneyOptions
-		def otm_options count:  5,  right: :put, ref_price: :request, sort: :strike
-			option_chain( right: right, ref_price: ref_price, sort: sort ) do | chain |
-					if right == :put
-						#			puts "Chain: #{chain}"
-						below_market_price_strikes = chain[-1][-count..-1].reverse
-					else
-						above_market_price_strikes = chain[1][0..count-1]
-					end
-			end
-		end
-
-
-		def associate_ticdata
-
-			tws=  IB::Connection.current 		 # get the initialized ib-ruby instance
-			the_id =  nil
-			finalize= false
-			#  switch to delayed data
-			tws.send_message :RequestMarketDataType, :market_data_type => :delayed
-
-			s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	finalize = true	if msg.ticker_id == the_id }
-
-			sub_id = tws.subscribe(:TickPrice, :TickSize,  :TickGeneric, :TickOption) do |msg|
-				self.bars << msg.the_data if msg.ticker_id == the_id 
-			end
-
-			# 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 
-
-			#keep the method-call running until the request finished
-			#and cancel subscriptions to the message handler.
-			Thread.new do 
-				i=0; loop{ i+=1; sleep 0.1; break if finalize || i > 1000 }
-				tws.unsubscribe sub_id 
-				tws.unsubscribe s_id
-				#puts "#{symbol} data gathered" 
-			end  # method returns the (running) thread
-
-		end # def 
+
+  # returns the Option Chain of the contract (if available)
+  #
+  ## parameters
+  ### right:: :call, :put, :straddle
+  ### ref_price::  :request or a numeric value
+  ### sort:: :strike, :expiry
+  ### exchange:: List of Exchanges to be queried (Blank for all available Exchanges)
+  def option_chain ref_price: :request, right: :put, sort: :strike, exchange: ''
+
+    ib = Connection.current
+    finalize =  Queue.new
+
+    ## Enable Cashing of Definition-Matrix
+    @option_chain_definition ||= []
+
+    my_req = nil
+
+    # -----------------------------------------------------------------------------------------------------
+    # get OptionChainDefinition from IB ( instantiate cashed Hash )
+    if @option_chain_definition.blank?
+      sub_sdop = ib.subscribe( :SecurityDefinitionOptionParameterEnd ) { |msg| finalize.push(true) if msg.request_id == my_req }
+      sub_ocd = ib.subscribe( :OptionChainDefinition ) do | msg |
+        if msg.request_id == my_req
+          message = msg.data
+          # transfer the first record to @option_chain_definition
+          if @option_chain_definition.blank?
+            @option_chain_definition = msg.data
+          end
+          # override @option_chain_definition if a decent combination of attributes is met
+          # us- options:  use the smart dataset
+          # other options: prefer options of the default trading class
+          if message[:exchange] == 'SMART'
+            @option_chain_definition = msg.data
+            finalize.push(true)
+          end
+          if message[:trading_class] == symbol
+            @option_chain_definition = msg.data
+            finalize.push(true)
+          end
+        end
+      end
+
+      c = verify.first  #  ensure a complete set of attributes
+      my_req = ib.send_message :RequestOptionChainDefinition, con_id: c.con_id,
+        symbol: c.symbol,
+        exchange: c.sec_type == :future ? c.exchange : "", # BOX,CBOE',
+        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
+      Connection.logger.info { "#{to_human} : using cached data" }
+    end
+
+    # -----------------------------------------------------------------------------------------------------
+    # select values and assign to options
+    #
+    unless @option_chain_definition.blank? 
+      requested_strikes =  if block_given?  
+                             ref_price = market_price if ref_price == :request
+                             if ref_price.nil?
+                               ref_price =	 @option_chain_definition[:strikes].min  +
+                                 ( @option_chain_definition[:strikes].max -  
+                                  @option_chain_definition[:strikes].min ) / 2 
+                               Connection.logger.warn { "#{to_human} :: market price not set – using midpoint of available strikes instead: #{ref_price.to_f}" }
+                             end
+                             atm_strike = @option_chain_definition[:strikes].min_by { |x| (x - ref_price).abs }
+                             the_grouped_strikes = @option_chain_definition[:strikes].group_by{|e| e <=> atm_strike}	
+                             begin
+                               the_strikes =		yield the_grouped_strikes
+                               the_strikes.unshift atm_strike unless the_strikes.first == atm_strike	  # the first item is the atm-strike
+                               the_strikes
+                             rescue
+                               Connection.logger.error "#{to_human} :: not enough strikes :#{@option_chain_definition[:strikes].map(&:to_f).join(',')} "
+                               []
+                             end
+                           else
+                             @option_chain_definition[:strikes]
+                           end
+
+      # third Friday of a month
+      monthly_expirations =  @option_chain_definition[:expirations].find_all{|y| (15..21).include? y.day }
+      #				puts @option_chain_definition.inspect
+      option_prototype = -> ( ltd, strike ) do 
+        IB::Option.new symbol: symbol, 
+          exchange: @option_chain_definition[:exchange], 
+          trading_class: @option_chain_definition[:trading_class], 
+          multiplier: @option_chain_definition[:multiplier], 
+          currency: currency,  
+          last_trading_day: ltd, 
+          strike: strike, 
+          right: right  
+      end
+      options_by_expiry = -> ( schema ) do
+        # Array: [ yymm -> Options] prepares for the correct conversion to a Hash
+        Hash[  monthly_expirations.map do | l_t_d |
+          [  l_t_d.strftime('%y%m').to_i , schema.map{ | strike | option_prototype[ l_t_d, strike ]}.compact ]
+        end  ]                         # by Hash[ ]
+      end
+      options_by_strike = -> ( schema ) do
+        Hash[ schema.map do | strike |
+          [  strike ,   monthly_expirations.map{ | l_t_d | option_prototype[ l_t_d, strike ]}.compact ]
+        end  ]                         # by Hash[ ]
+      end
+
+      if sort == :strike
+        options_by_strike[ requested_strikes ] 
+      else 
+        options_by_expiry[ requested_strikes ] 
+      end
+    else
+      Connection.logger.error "#{to_human} ::No Options available"
+      nil # return_value
+    end
+  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 |
+      chain[0]
+    end
+
+
+  end
+
+  # return   InTheMoneyOptions
+  def itm_options count:  5, right: :put, ref_price: :request, sort: :strike
+    option_chain(  right: right,  ref_price: ref_price, sort: sort ) do | chain |
+      if right == :put
+        above_market_price_strikes = chain[1][0..count-1]
+      else
+        below_market_price_strikes = chain[-1][-count..-1].reverse
+      end # branch
+    end
+  end		# def
+
+  # return OutOfTheMoneyOptions
+  def otm_options count:  5,  right: :put, ref_price: :request, sort: :strike
+    option_chain( right: right, ref_price: ref_price, sort: sort ) do | chain |
+      if right == :put
+        #			puts "Chain: #{chain}"
+        below_market_price_strikes = chain[-1][-count..-1].reverse
+      else
+        above_market_price_strikes = chain[1][0..count-1]
+      end
+    end
+  end
+
+
+  def associate_ticdata
+
+    tws=  IB::Connection.current 		 # get the initialized ib-ruby instance
+    the_id =  nil
+    finalize= false
+    #  switch to delayed data
+    tws.send_message :RequestMarketDataType, :market_data_type => :delayed
+
+    s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	finalize = true	if msg.ticker_id == the_id }
+
+    sub_id = tws.subscribe(:TickPrice, :TickSize,  :TickGeneric, :TickOption) do |msg|
+      self.bars << msg.the_data if msg.ticker_id == the_id 
+    end
+
+    # 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 
+
+    #keep the method-call running until the request finished
+    #and cancel subscriptions to the message handler.
+    Thread.new do 
+      i=0; loop{ i+=1; sleep 0.1; break if finalize || i > 1000 }
+      tws.unsubscribe sub_id 
+      tws.unsubscribe s_id
+      #puts "#{symbol} data gathered" 
+    end  # method returns the (running) thread
+
+  end # def 
 end # class
 
 

data/lib/ib/order-prototypes.rb

@@ -67,7 +67,7 @@ module IB
 			end
 
 			# initialise order with given attributes	
-			IB::Order.new the_arguments
+			IB::Order.new **the_arguments
 		end
 
 		def alternative_parameters

data/lib/ib/spread-prototypes.rb

@@ -1,4 +1,4 @@
-require 'ib/models/spread'
+#require 'ib/models/spread'
 require 'ib/verify'
 # These modules are used to facilitate referencing of most common Spreads 
 
@@ -24,7 +24,7 @@ module IB
 
 		def initialize_spread ref_contract = nil, **attributes
 			error "Initializing of Spread failed – contract is missing" unless ref_contract.is_a?(IB::Contract)
-			the_contract =  ref_contract.merge( attributes ).verify.first
+			the_contract =  ref_contract.merge( **attributes ).verify.first
 			error "Underlying for Spread is not valid: #{ref_contract.to_human}" if the_contract.nil?
 			the_spread= IB::Spread.new  the_contract.attributes.slice( :exchange, :symbol, :currency )
 			error "Initializing of Spread failed – Underling is no Contract" if the_spread.nil?

data/lib/ib/spread_prototypes/stock-spread.rb

@@ -19,7 +19,7 @@ module IB
 				def  fabricate *underlying,  ratio: [1,-1], **args
 					#
 					are_stocks =  ->(l){ l.all?{|y| y.is_a? IB::Stock} }
-					legs = underlying.map{|y| y.is_a?( IB::Stock ) ? y.merge(args) : IB::Stock.new( symbol: y ).merge(args)}
+					legs = underlying.map{|y| y.is_a?( IB::Stock ) ? y.merge(**args) : IB::Stock.new( symbol: y ).merge(**args)}
 					error "only spreads with two underyings of type »IB::Stock« are supported" unless legs.size==2 && are_stocks[legs]
 					initialize_spread( legs.first ) do | the_spread |
 						c_l = legs.zip(ratio).map do |l,r| 

data/lib/ib/verify.rb

@@ -1,226 +1,196 @@
 module IB
 	# define a custom ErrorClass which can be fired if a verification fails
-	class VerifyError < StandardError
-	end
-
-	class Contract
-
-		
-		# IB::Contract#Verify 
-
-		# verifies the contract 
-		#
-		# returns the number of contracts retured by the TWS.
-		# 
-		# 
-		# The method accepts a block. The  queried contract-Object is assessible there.
-		# If multible contracts are specified, the block is executed with each of these contracts.
-		#
-		# Parameter: thread: (true/false) 
-		#
-		# The verifiying-process ist time consuming. If multible contracts are to be verified, 
-		# they can be queried simultaniously.
-		#    IB::Symbols::W500.map{|c|  c.verify(thread: true){ |vc| do_something }}.join
-		# 
-		# A simple verification works as follows:
-		# 
-		#  s = IB::Stock.new symbol:"A"  
-		#  s --> <IB::Stock:0x007f3de81a4398 
-		#  	  @attributes= {"symbol"=>"A", "sec_type"=>"STK", "currency"=>"USD", "exchange"=>"SMART"}> 
-		#  s.verify   --> 1
-		#  # s is unchanged !
-		#	 
-		#  s.verify{ |c| puts c.inspect }
-		#   --> <IB::Stock:0x007f3de81a4398
-		#       @attributes={"symbol"=>"A",  "updated_at"=>2015-04-17 19:20:00 +0200,
-		# 		  "sec_type"=>"STK", "currency"=>"USD", "exchange"=>"SMART", 
-		# 		  "con_id"=>1715006, "expiry"=>"", "strike"=>0.0, "local_symbol"=>"A",
-		# 		  "multiplier"=>0, "primary_exchange"=>"NYSE"}, 
-		#       @contract_detail=#<IB::ContractDetail:0x007f3de81ed7c8 
-		# 		    @attributes={"market_name"=>"A", "trading_class"=>"A", "min_tick"=>0.01,
-		# 		    "order_types"=>"ACTIVETIM, (...),WHATIF,", 
-		# 		    "valid_exchanges"=>"SMART,NYSE,CBOE,ISE,CHX,(...)PSX", 
-		# 		    "price_magnifier"=>1, "under_con_id"=>0, 
-		# 		    "long_name"=>"AGILENT TECHNOLOGIES INC", "contract_month"=>"",
-		# 		    "industry"=>"Industrial", "category"=>"Electronics",
-		# 		    "subcategory"=>"Electronic Measur Instr", "time_zone"=>"EST5EDT",
-		# 		    "trading_hours"=>"20150417:0400-2000;20150420:0400-2000",
-		# 		    "liquid_hours"=>"20150417:0930-1600;20150420:0930-1600", 
-		# 		    "ev_rule"=>0.0, "ev_multiplier"=>"", "sec_id_list"=>{}, 
-		# 		    "updated_at"=>2015-04-17 19:20:00 +0200, "coupon"=>0.0, 
-		# 		    "callable"=>false, "puttable"=>false, "convertible"=>false,
-		# 		    "next_option_partial"=>false}>> 
-		# 
-		# 
-		def  verify  thread: nil,  &b 
-			return [self] if contract_detail.present? || sec_type == :bag
-			_verify update: false, thread: thread,  &b  # returns the allocated threads
-		end # def
-
-		# returns a hash 
-		def nessesary_attributes
-
-  v= { stock:  { currency: 'USD', exchange: 'SMART', symbol: nil} ,
-	  option: { currency: 'USD', exchange: 'SMART', right: 'P', expiry: nil, strike: nil, symbol:  nil} ,
-	  future: { currency: 'USD', exchange: nil, expiry: nil,  symbol: nil } , 
-    forex:  { currency: 'USD', exchange: 'IDEALPRO', symbol: nil }
-	}
-  sec_type.present? ?	v[sec_type] : { con_id: nil, exchange: 'SMART' }  # enables to use only con_id for verifying
+#	class VerifyError < StandardError
+#	end
+
+  class Contract
+
+    # IB::Contract#Verify
+
+    # verifies the contract
+    #
+    # returns the number of contracts returned by the TWS.
+    #
+    #
+    # The method accepts a block. The  queried contract-Object is accessible there.
+    # If multiple contracts are specified, the block is executed with each of these contracts.
+    #
+    #
+    # Verify returns an  _Array_ of contracts. The  operation leaves the contract untouched.
+    # 
+    #
+    # Returns nil if the contract could not be verified.
+    #
+    #	 > s =  Stock.new symbol: 'AA'
+    #     => #<IB::Stock:0x0000000002626cc0
+    #        @attributes={:symbol=>"AA", :con_id=>0, :right=>"", :include_expired=>false,
+    #                     :sec_type=>"STK", :currency=>"USD", :exchange=>"SMART"}
+    #  > sp  = s.verify.first.essential
+    #     => #<IB::Stock:0x00000000025a3cf8
+    #        @attributes={:symbol=>"AA", :con_id=>251962528, :exchange=>"SMART", :currency=>"USD",
+    #                     :strike=>0.0, :local_symbol=>"AA", :multiplier=>0, :primary_exchange=>"NYSE",
+    #                     :trading_class=>"AA", :sec_type=>"STK", :right=>"", :include_expired=>false}
+    #
+    #  > s =  Stock.new symbol: 'invalid'
+    #     =>  @attributes={:symbol=>"invalid", :sec_type=>"STK", :currency=>"USD", :exchange=>"SMART"}
+    #  >  sp  = s.verify
+    #     => []
+    #
+    # Takes a Block to modify the queried contracts
+    #
+    # f = Future.new  symbol: 'M2K'  
+    # con_ids =  f.verify{ |c| c.con_id }
+    #   [412889018, 428519982, 446091466, 461318872, 477836981] 
+    #
+    #
+    # Parameter: thread: (true/false)
+    #
+    # If multiple contracts are to be verified, they can be queried simultaneously.
+    #    IB::Symbols::W500.map{|c|  c.verify(thread: true){ |vc| do_something }}.join
+
+    def verify thread: nil, &b
+      return [self] if contract_detail.present? || sec_type == :bag
+      _verify update: false, thread: thread,  &b  # returns the allocated threads
+    end # def
+
+    # returns a hash
+    def nessesary_attributes
+
+      v= { stock:  { currency: 'USD', exchange: 'SMART', symbol: nil},
+           option: { currency: 'USD', exchange: 'SMART', right: 'P', expiry: nil, strike: nil, symbol:  nil},
+           future: { currency: 'USD', exchange: nil, expiry: nil,  symbol: nil },
+           forex:  { currency: 'USD', exchange: 'IDEALPRO', symbol: nil }
+      }
+      sec_type.present? ?	v[sec_type] : { con_id: nil, exchange: 'SMART' } # enables to use only con_id for verifying
 																																				# if the contract allows SMART routing
-		end
-
-		# Verify that the contract is a valid IB::Contract, update the Contract-Object and return it.
-		#
-		# Returns nil if the contract could not be verified. 
-		# 
-		#	 > s =  Stock.new symbol: 'AA'
-		#     => #<IB::Stock:0x0000000002626cc0 
-		#        @attributes={:symbol=>"AA", :con_id=>0, :right=>"", :include_expired=>false, 
-		#                     :sec_type=>"STK", :currency=>"USD", :exchange=>"SMART"}
-		#  > sp  = s.verify! &.essential
-		#     => #<IB::Stock:0x00000000025a3cf8 
-		#        @attributes={:symbol=>"AA", :con_id=>251962528, :exchange=>"SMART", :currency=>"USD",
-		#                     :strike=>0.0, :local_symbol=>"AA", :multiplier=>0, :primary_exchange=>"NYSE", 
-		#                     :trading_class=>"AA", :sec_type=>"STK", :right=>"", :include_expired=>false}
-		#                   
-		#  > s =  Stock.new symbol: 'invalid'
-		#     =>  @attributes={:symbol=>"invalid", :sec_type=>"STK", :currency=>"USD", :exchange=>"SMART"}
-		#  >  sp  = s.verify! &.essential
-		#     => nil
-
-		def verify!
-			return self if contract_detail.present? || sec_type == :bag
-			c =  0
-			_verify( update: true){| response | c+=1 } # wait for the returned thread to finish
-			IB::Connection.logger.error { "Multible Contracts detected during verify!."  } if c > 1
-			con_id.to_i < 0 || contract_detail.is_a?(ContractDetail) ? self :  nil
-		end
-
-#		private
-
-		# Base method to verify a contract
-		# 
-		# if :thread is given, the method subscribes to messages, fires the request and returns the thread, that 
-		# receives the exit-condition-message
-		# 
-		# otherwise the method waits until the response form tws is processed
-		# 
-		# 
-		# if :update is true, the attributes of the Contract itself are apdated
-		# 
-		# otherwise the Contract is untouched
-		def _verify thread: nil , update:,  &b # :nodoc:
-
-			ib =  Connection.current
-			# we generate a Request-Message-ID on the fly
-			message_id = nil 
-			# define local vars which are updated within the query-block
-			exitcondition, count , queried_contract, r = false, 0, nil, []
-
-			# currently the tws-request is suppressed for bags and if the contract_detail-record is present
-			tws_request_not_nessesary = bag? || contract_detail.is_a?( ContractDetail )
-
-			if tws_request_not_nessesary
-				yield self if block_given?
-				count = 1
-			else # subscribe to ib-messages and describe what to do
-				a = ib.subscribe(:Alert, :ContractData,  :ContractDataEnd) do |msg| 
-					case msg
-					when Messages::Incoming::Alert
-						if msg.code == 200 && msg.error_id == message_id
-							ib.logger.error { "Not a valid Contract :: #{self.to_human} " }
-							exitcondition = true
-						end
-					when Messages::Incoming::ContractData
-						if msg.request_id.to_i == message_id
-							# if multible contracts are present, all of them are assigned
-							# Only the last contract is saved in self;  'count' is incremented
-							count +=1
-							## a specified block gets the contract_object on any uniq ContractData-Event
-							r << if block_given?
-										 yield msg.contract
-							elsif count > 1 
-								queried_contract = msg.contract  # used by the logger (below) in case of mulible contracts
-							else
-								msg.contract
-							end
-							if update
-								self.attributes = msg.contract.attributes
-								self.contract_detail = msg.contract_detail unless msg.contract_detail.nil?
-							end
-						end
-					when Messages::Incoming::ContractDataEnd
-						exitcondition = true if msg.request_id.to_i ==  message_id
-
-					end  # case
-				end # subscribe
-
-				### send the request !
-			#	contract_to_be_queried =  con_id.present? ? self : query_contract  
-				# if no con_id is present,  the given attributes are checked by query_contract
-			#	if contract_to_be_queried.present?   # is nil if query_contract fails
-					message_id = ib.send_message :RequestContractData, :contract => query_contract
-
-					th =  Thread.new do
-						begin
-							Timeout::timeout(1) do
-								loop{ break if exitcondition ; sleep 0.005 } 
-							end
-						rescue Timeout::Error
-							Connection.logger.error{ "#{to_human} --> No ContractData recieved " }
-						end
-						ib.unsubscribe a
-					end
-					if thread.nil?
-						th.join    # wait for the thread to finish
-						r			 # return array of contracts
-					else
-						th			# return active thread
-					end
-	#			else
-	#				ib.logger.error { "Not a valid Contract-spezification, #{self.to_human}" }
-				end
-	#		end
-		end
-
-		# Generates an IB::Contract with the required attributes to retrieve a unique contract from the TWS
-		# 
-		# Background: If the tws is queried with a »complete« IB::Contract, it fails occacionally.
-		# So – even to update its contents, a defined subset of query-parameters  has to be used.
-		# 
-		# The required data-fields are stored in a yaml-file and fetched by #YmlFile.
-		# 
-		# If `con_id` is present, only `con_id` and `exchange` are transmitted to the tws.
-		# Otherwise a IB::Stock, IB::Option, IB::Future or IB::Forex-Object with necessary attributes
-		# to query the tws is build (and returned)
-		# 
-		# If Attributes are missing, an IB::VerifyError is fired,
-		# This can be trapped with 
-		#   rescue IB::VerifyError do ...
-
-		def  query_contract( invalid_record: true )  # :nodoc:
-			# don't raise a verify error at this time. Contract.new con_id= xxxx, currency = 'xyz' is also valid
-		##	raise VerifyError, "Querying Contract faild: Invalid Security Type" unless SECURITY_TYPES.values.include? sec_type
-
-			## the yml contains symbol-entries
-			## these are converted to capitalized strings 
-			items_as_string = ->(i){i.map{|x,y| x.to_s.capitalize}.join(', ')}
-			## here we read the corresponding attributes of the specified contract 
-			item_values = ->(i){ i.map{|x,y| self.send(x).presence || y }}
-			## and finally we create a attribute-hash to instantiate a new Contract
-			## to_h is present only after ruby 2.1.0
-			item_attributehash = ->(i){ i.keys.zip(item_values[i]).to_h }
-			## now lets proceed, but only if no con_id is present
-			if con_id.blank? || con_id.zero?
-#				if item_values[nessesary_attributes].any?( &:nil? ) 
-#					raise VerifyError, "#{items_as_string[nessesary_attributes]} are needed to retrieve Contract,
-#																	got: #{item_values[nessesary_attributes].join(',')}"
-#				end
-	#			Contract.build  item_attributehash[nessesary_items].merge(:sec_type=> sec_type)  # return this
-				Contract.build  self.attributes # return this
-			else   # its always possible, to retrieve a Contract if con_id and exchange  or are present 
-				Contract.new  con_id: con_id , :exchange => exchange.presence || item_attributehash[nessesary_attributes][:exchange].presence || 'SMART'				# return this
-			end  # if 
-		end # def
-	end # class
+    end
+
+    #
+    #   depreciated:  Do not use  anymore
+    def verify!
+      c =  0
+      IB::Connection.logger.warn "Contract.verify! is depreciated. Use \"contract =  contract.verify.first\" instead"
+      _verify( update: true){| response | c+=1 } # wait for the returned thread to finish
+      IB::Connection.logger.error { "Multible Contracts detected during verify!."  } if c > 1
+      self
+    end
+
+		private
+
+    # Base method to verify a contract
+    #
+    # if :thread is given, the method subscribes to messages, fires the request and returns the thread, that
+    # receives the exit-condition-message
+    #
+    # otherwise the method waits until the response form tws is processed
+    #
+    #
+    # if :update is true, the attributes of the Contract itself are adapted
+    #
+    # otherwise the Contract is untouched
+    def _verify thread: nil , update:,  &b # :nodoc:
+      ib = Connection.current
+      # we generate a Request-Message-ID on the fly
+      message_id = nil
+      # define local vars which are updated within the query-block
+      recieved_contracts = []
+      queue = Queue.new
+      a = nil
+
+      # a tws-request is suppressed for bags and if the contract_detail-record is present
+      tws_request_not_nessesary = bag? || contract_detail.is_a?( ContractDetail )
+
+      if tws_request_not_nessesary
+        yield self if block_given?
+        return self
+      else # subscribe to ib-messages and describe what to do
+        a = ib.subscribe(:Alert, :ContractData,  :ContractDataEnd) do |msg|
+          case msg
+          when Messages::Incoming::Alert
+            if msg.code == 200 && msg.error_id == message_id
+              ib.logger.error { "Not a valid Contract :: #{self.to_human} " }
+              queue.close
+            end
+          when Messages::Incoming::ContractData
+            if msg.request_id.to_i == message_id
+              # if multiple contracts are present, all of them are assigned
+              # Only the last contract is saved in self;  'count' is incremented
+              ## a specified block gets the contract_object on any unique ContractData-Event
+              recieved_contracts << if block_given?
+                                      yield msg.contract
+              else
+                msg.contract
+              end
+              if update
+                self.attributes = msg.contract.attributes
+                self.contract_detail = msg.contract_detail unless msg.contract_detail.nil?
+              end
+            end
+          when Messages::Incoming::ContractDataEnd
+            queue.push(1) if  msg.request_id.to_i == message_id
+
+          end  # case
+        end # subscribe
+
+        ### send the request !
+        #	contract_to_be_queried =  con_id.present? ? self : query_contract
+        # if no con_id is present,  the given attributes are checked by query_contract
+        #	if contract_to_be_queried.present?   # is nil if query_contract fails
+        message_id = ib.send_message :RequestContractData, :contract => query_contract
+
+        th =  Thread.new do
+          queue.pop
+#          j=0; loop{ sleep(0.01);  j+=1; break if queue.closed? || queue.pop || j> 100; }
+#          ib.logger.error{ "#{to_human} --> No ContractData recieved " } if j >= 100 && !queue.closed?
+          ib.unsubscribe a
+        end
+        if thread.nil?
+          th.join    # wait for the thread to finish
+          recieved_contracts			 # return queue of contracts
+        else
+          th			# return active thread
+        end
+      end
+    end
+
+    # Generates an IB::Contract with the required attributes to retrieve a unique contract from the TWS
+    #
+    # Background: If the tws is queried with a »complete« IB::Contract, it fails occasionally.
+    # So – even to update its contents, a defined subset of query-parameters  has to be used.
+    #
+    # The required data-fields are stored in a yaml-file and fetched by #YmlFile.
+    #
+    # If `con_id` is present, only `con_id` and `exchange` are transmitted to the tws.
+    # Otherwise a IB::Stock, IB::Option, IB::Future or IB::Forex-Object with necessary attributes
+    # to query the tws is build (and returned)
+    #
+    # If Attributes are missing, an IB::VerifyError is fired,
+    # This can be trapped with 
+    #   rescue IB::VerifyError do ...
+
+    def  query_contract( invalid_record: true )  # :nodoc:
+      # don't raise a verify error at this time. Contract.new con_id= xxxx, currency = 'xyz' is also valid
+      ##	raise VerifyError, "Querying Contract failed: Invalid Security Type" unless SECURITY_TYPES.values.include? sec_type
+
+      ## the yml contains symbol-entries
+      ## these are converted to capitalized strings
+      items_as_string = ->(i){i.map{|x,y| x.to_s.capitalize}.join(', ')}
+      ## here we read the corresponding attributes of the specified contract
+      item_values = ->(i){ i.map{|x,y| self.send(x).presence || y }}
+      ## and finally we create a attribute-hash to instantiate a new Contract
+      ## to_h is present only after ruby 2.1.0
+      item_attributehash = ->(i){ i.keys.zip(item_values[i]).to_h }
+      ## now lets proceed, but only if no con_id is present
+      if con_id.blank? || con_id.zero?
+        #				if item_values[necessary_attributes].any?( &:nil? )
+        #					raise VerifyError, "#{items_as_string[necessary_attributes]} are needed to retrieve Contract,
+        #																	got: #{item_values[necessary_attributes].join(',')}"
+        #				end
+        #			Contract.build  item_attributehash[necessary_items].merge(:sec_type=> sec_type)  # return this
+        Contract.build  self.invariant_attributes # return this
+      else   # its always possible, to retrieve a Contract if con_id and exchange  or are present
+        Contract.new  con_id: con_id , :exchange => exchange.presence || item_attributehash[nessesary_attributes][:exchange].presence || 'SMART'				# return this
+      end  # if
+    end # def
+  end
 end #module