ib-extensions 1.2 → 1.3.1

data/lib/ib/order_prototypes/all-in-one.rb

@@ -0,0 +1,46 @@
+module IB
+
+#Combo-Orders are used for NonGuaranteed Orders only.
+#»Normal« Option-Spreads are transmited by ordinary Limit-Orders
+    module Combo
+      ### Basic Order Prototype: Combo with two limits
+      extend OrderPrototype
+      class << self
+      def defaults
+	## todo implement serialisation of  key/tag Hash to camelCased-keyValue-List 
+#      super.merge order_type: :limit , combo_params: { non_guaranteed: true} 
+	#      for the time being, we use the array representation
+      super.merge order_type: :limit , combo_params: [ ['NonGuaranteed', true] ]
+      end
+
+
+      def requirements
+				Limit.requirements
+      end
+
+      def aliases
+				Limit.aliases
+      end
+
+
+      def summary
+	<<-HERE
+	Create combination orders. It is constructed through  options, stock and futures legs 
+	(stock legs can be included if the order is routed through SmartRouting). 
+	
+	Although a combination/spread order is constructed of separate legs, it is executed 
+	as a single transaction if it is routed directly to an exchange. For combination orders 
+	that are SmartRouted, each leg may be executed separately to ensure best execution. 
+
+	The »NonGuaranteed«-Flag is set to "false". A Pair of two securites should always be
+	routed »Guaranteed«, otherwise separate orders are prefered.
+
+	If a Bag-Order with »NonGuarateed :true« should be submitted, the Order-Type would be 
+	REL+MKT, LMT+MKT, or REL+LMT 
+	--------
+	Products: Options, Stocks, Futures
+	HERE
+      end # def
+      end # class
+    end	# module combo
+end  # module ib

data/lib/ib/plot-poec.rb

@@ -0,0 +1,60 @@
+require 'distribution'
+require 'gnuplot'
+
+## source:  ChatGpt
+# Set the variables
+s = 100 # current stock price
+k = 110 # strike price
+t = 0.5 # time to expiry (in years)
+r = 0.02 # risk-free interest rate
+sigma = 0.2 # implied volatility
+p = 0.7 # probability
+
+# Calculate d1 and d2
+d1 = (Math.log(s/k) + (r + 0.5*sigma**2)*t) / (sigma * Math.sqrt(t))
+d2 = d1 - sigma * Math.sqrt(t)
+
+# Calculate the Z-score for the desired probability
+z_score = Distribution::Normal.inv_cdf(p + (1-p)/2)
+
+# Calculate the upper and lower bounds of the 70% probability range
+upper_bound = s * Math.exp((r - 0.5*sigma**2)*t + sigma*Math.sqrt(t)*z_score)
+lower_bound = s * Math.exp((r - 0.5*sigma**2)*t + sigma*Math.sqrt(t)*(-z_score))
+
+# Create the plot
+Gnuplot.open do |gp|
+  Gnuplot::Plot.new(gp) do |plot|
+    plot.title 'Probability Density Function with 70% probability range'
+    plot.xlabel 'Stock Price'
+    plot.ylabel 'Probability Density'
+
+    # Set the x-axis range
+    plot.xrange "[#{s*0.6}:#{s*1.4}]"
+
+    # Plot the probability density function
+    x = (s*0.6..s*1.4).step(0.1).to_a
+    y = x.map { |xi| Distribution::Normal.pdf((Math.log(xi/s) + (r - 0.5*sigma**2)*t) / (sigma * Math.sqrt(t))) / (xi*sigma*Math.sqrt(t))  }
+    plot.data << Gnuplot::DataSet.new([x, y]) do |ds|
+      ds.with = 'lines'
+      ds.linewidth = 2
+      ds.linecolor = 'blue'
+    end
+
+    # Plot the upper and lower bounds of the 70% probability range
+    plot.data << Gnuplot::DataSet.new([lower_bound, 0]) do |ds|
+      ds.with = 'lines'
+      ds.linewidth = 2
+      ds.linecolor = 'red'
+    end
+    plot.data << Gnuplot::DataSet.new([upper_bound, 0]) do |ds|
+      ds.with = 'lines'
+      ds.linewidth = 2
+      ds.linecolor = 'red'
+    end
+    plot.data << Gnuplot::DataSet.new([[lower_bound, upper_bound], [0, 0]]) do |ds|
+      ds.with = 'filledcurve x1=1 x2=2'
+      ds.fillcolor = 'red'
+      ds.fillstyle = 'transparent solid 0.2'
+    end
+  end
+end

data/lib/ib/probability_of_expiring.rb

@@ -0,0 +1,109 @@
+module IB
+  module ProbabilityOfExpiring
+
+    # Use  by calling
+    #   a = Stock.new symbol: 'A'
+    #
+    require 'prime'
+    require 'distribution'
+
+
+
+    def probability_of_assignment  **args
+      ( probability_of_expiring(**args) - 1 ).abs
+    end
+    def probability_of_expiring  **args
+      @probability_of_expiring = calculate_probability_of_expiring(**args) if @probability_of_expiring.nil? ||  ! args.empty?
+      @probability_of_expiring
+    end
+
+    private
+=begin
+Here are the steps to calculate the probability of expiry cone for a stock in
+the next six months using the Black-Scholes model:
+
+*  Determine the current stock price and the strike price for the option you
+   are interested in. Let's say the current stock price is $100 and the strike
+   price is $110.  *  Determine the time to expiry. In this case, we are
+   interested in the next six months, so the time to expiry is 0.5 years.  *
+   Determine the implied volatility of the stock. Implied volatility is a measure
+   of the expected volatility of the stock over the life of the option, and can be
+   estimated from the option prices in the market.
+
+* Use the Black-Scholes formula to calculate the probability of the stock
+  expiring within the range of prices that make up the expiry cone. The formula
+  is:
+
+                    P = N(d2)
+
+  Where P is the probability of the stock expiring within the expiry cone, and
+  N is the cumulative distribution function of the standard normal
+  distribution. d2 is calculated as:
+
+                    d2 = (ln(S/K) + (r - 0.5 * σ^2) * T) / (σ * sqrt(T))
+
+  Where S is the current stock price, K is the strike price, r is the risk-free
+  interest rate, σ is the implied volatility, and T is the time to expiry.
+
+  Look up the value of N(d2) in a standard normal distribution table, or use a
+  calculator or spreadsheet program that can calculate cumulative distribution
+  functions.
+
+  The result is the probability of the stock expiring within the expiry cone.
+  For example, if N(d2) is 0.35, then the probability of the stock expiring
+                 within the expiry cone is 35%.
+
+(ChatGPT)
+=end
+    def calculate_probability_of_expiring price: nil,
+                                          interest: 0.03,
+                                          iv: nil,
+                                          strike: nil,
+                                          expiry: nil,
+                                          ref_date: Date.today
+
+      if iv.nil?  && self.respond_to?( :greek )
+        IB::Connection.current.logger.info "Probability_of_expiring: using current IV and Underlying-Price for calculation"
+          request_greeks if greek.nil?
+          iv = greek.implied_volatility
+          price = greek.under_price if price.nil?
+      end
+      error "ProbabilityOfExpiringCone needs iv as input" if iv.nil? || iv.zero?
+
+      if price.nil?
+        price =  if self.strike.to_i.zero?
+                   market_price
+                 else
+                   underlying.market_price
+                 end
+      end
+      error "ProbabilityOfExpiringCone needs price as input" if price.to_i.zero?
+
+
+      strike ||= self.strike
+      error "ProbabilityOfExpiringCone needs strike as input" if strike.to_i.zero?
+
+      if expiry.nil?
+        if last_trading_day == ''
+          error "ProbabilityOfExpiringCone needs expiry as input"
+        else
+          expiry = last_trading_day
+        end
+      end
+      time_to_expiry = ( Date.parse( expiry.to_s ) - ref_date ).to_i
+
+      # # Calculate d1 and d2
+      d1 = (Math.log(price/strike.to_f) + (interest + 0.5*iv**2)*time_to_expiry) / (iv * Math.sqrt(time_to_expiry))
+      d2 = d1 - iv * Math.sqrt(time_to_expiry)
+      #
+      # # Calculate the probability of expiry cone
+      Distribution::Normal.cdf(d2)
+
+    end
+  end
+
+  class Contract
+    include ProbabilityOfExpiring
+  end
+
+end

data/lib/ib/spread-prototypes.rb

@@ -24,6 +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)
+      # make sure that :exchange, :symbol and :currency are present
 			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 )

data/lib/ib/spread_prototypes/butterfly.rb

@@ -25,8 +25,7 @@ module IB
 					error "fabrication is based on a master option. Please specify as first argument" unless master.is_a?(IB::Option)
 					strike = master.strike
 					master.right = :put unless master.right == :call
-					l=[] ; master.verify{|x| x.contract_detail= nil; l << x }
-#					puts "master:  #{master.attributes.inspect}"
+					l= master.verify
 					if l.empty?
 						error "Invalid Parameters. No Contract found #{master.to_human}" 
 					elsif l.size > 1
@@ -43,7 +42,7 @@ module IB
 						strikes = [front, master.strike, back]
 						strikes.zip([1, -2, 1]).each do |strike, ratio|
 							action = ratio >0 ?  :buy : :sell
-							leg =  IB::Option.new( master.attributes.merge( strike: strike )).verify!.essential
+              leg =  IB::Option.new( master.attributes.merge( strike: strike )).verify.first.essential
 							the_spread.add_leg  leg,  action: action,  ratio: ratio.abs 
 						end
 						the_spread.description =  the_description( the_spread )
@@ -53,7 +52,6 @@ module IB
 
 				def  build from: , front:, back:,  **options
 					underlying_attributes =  { expiry: IB::Symbols::Futures.next_expiry, right: :put }.merge( from.attributes.slice( :symbol, :currency, :exchange, :strike )).merge( options )
-					puts underlying_attributes.inspect
 					fabricate  IB::Option.new( underlying_attributes), front: front, back: back
 				end
 

data/lib/ib/spread_prototypes/calendar.rb

@@ -16,16 +16,13 @@ module IB
 			def fabricate master, the_other_expiry
 
 				error "Argument must be a IB::Future or IB::Option" unless  [:option, :future_option, :future ].include? master.sec_type
-
-				initialize_spread( master ) do | the_spread |
-					the_spread.add_leg master, action: :buy
-					
-					the_other_expiry =  the_other_expiry.values.first if the_other_expiry.is_a?(Hash)
-					back = the_spread.transform_distance master.expiry, the_other_expiry
-					the_spread.add_leg master.merge(expiry: back ), action: :sell
-					error "Initialisation of Legs failed" if the_spread.legs.size != 2
-					the_spread.description =  the_description( the_spread )
-				end
+        m = master.verify.first
+        the_other_expiry =  the_other_expiry.values.first if the_other_expiry.is_a?(Hash)
+        back = IB::Spread.transform_distance m.expiry, the_other_expiry
+        calendar =  m.roll expiry: back
+        error "Initialisation of Legs failed" if calendar.legs.size != 2
+				calendar.description =  the_description( calendar )
+        calendar  #  return fabricated spread
 			end
 
 
@@ -46,25 +43,30 @@ module IB
 											 fields[:expiry] = from.expiry unless fields.key?(:expiry)
 											 fields[:trading_class] = from.trading_class unless fields.key?(:trading_class) || from.trading_class.empty?
 											 fields[:multiplier] = from.multiplier unless fields.key?(:multiplier) || from.multiplier.to_i.zero?
-											 details =  nil; from.verify{|c| details = c.contract_detail }
+                       details = from.verify.first.contract_detail 
 											 IB::Contract.new( con_id: details.under_con_id, 
-																				currency: from.currency)
-																			 .verify!
-																			 .essential
+																				currency: from.currency).verify.first.essential
 										 else
 											 from
 										 end
 				kind = { :front => fields.delete(:front), :back => fields.delete(:back) }
-				error "Specifiaction of :front and :back expiries nessesary, got: #{kind.inspect}" if kind.values.any?(nil)
+				error "Specifiaction of :front and :back expiries necessary, got: #{kind.inspect}" if kind.values.any?(nil)
 				initialize_spread( underlying ) do | the_spread |
-					leg_prototype  = IB::Option.new underlying.attributes
-															.slice( :currency, :symbol, :exchange)
-															.merge(defaults)
-															.merge( fields )
-					kind[:back] = the_spread.transform_distance kind[:front], kind[:back]
+          leg_prototype  = IB::Option.new underlying.attributes
+            .slice( :currency, :symbol, :exchange)
+            .merge(defaults)
+            .merge( fields )
+					kind[:back] = IB::Spread.transform_distance kind[:front], kind[:back]
 					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
-					the_spread.add_leg IB::Contract.build( leg_prototype.attributes.merge(expiry: kind[:front] )), action: :buy
-					the_spread.add_leg IB::Contract.build( leg_prototype.attributes.merge(expiry: kind[:back])), action: :sell
+          leg1 =  leg_prototype.merge(expiry: kind[:front] ).verify.first
+          leg2 = leg_prototype.merge(expiry: kind[:back] ).verify.first
+          unless leg2.is_a? IB::Option
+            leg2_trading_class = ''
+            leg2 = leg_prototype.merge(expiry: kind[:back] ).verify.first
+
+          end
+          the_spread.add_leg leg1 , action: :buy
+          the_spread.add_leg leg2 , action: :sell
 					error "Initialisation of Legs failed" if the_spread.legs.size != 2
 					the_spread.description =  the_description( the_spread )
 				end
@@ -78,7 +80,7 @@ module IB
 
 			def the_description spread
 			x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:last_trading_day )].transpose
-			 "<Calendar #{spread.symbol} #{spread.legs.first.right}(#{spread.legs.first.strike})[#{x.map{|w,l_t_d| "#{w} :#{Date.parse(l_t_d).strftime("%b %Y")} "}.join( '|+|' )} >"
+		 "<Calendar #{spread.symbol} #{spread.legs.first.right}(#{spread.legs.first.strike})[#{x.map{|w,l_t_d| "#{w} :#{Date.parse(l_t_d).strftime("%b %Y")} "}.join( '|+|' )} >"
 			end
 		 end # class
     end	# module vertical

data/lib/ib/spread_prototypes/straddle.rb

@@ -43,11 +43,11 @@ module IB
 						leg_prototype  = IB::Option.new from.attributes
 						.slice( :currency, :symbol, :exchange)
 						.merge(defaults)
-						.merge( fields )
+              .merge( fields )
 
 						leg_prototype.sec_type = 'FOP' if from.is_a?(IB::Future)
-						the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :put )
-						the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :call )
+            the_spread.add_leg leg_prototype.merge( right: :put ).verify.first
+            the_spread.add_leg leg_prototype.merge( right: :call ).verify.first
 						error "Initialisation of Legs failed" if the_spread.legs.size != 2
 						the_spread.description =  the_description( the_spread )
 					end

data/lib/ib/spread_prototypes/strangle.rb

@@ -60,15 +60,14 @@ module IB
 										 end
 				kind = { :p => fields.delete(:p), :c => fields.delete(:c) }
 				initialize_spread( underlying ) do | the_spread |
-					leg_prototype  = IB::Option.new underlying.attributes
-															.slice( :currency, :symbol, :exchange)
-															.merge(defaults)
-															.merge( fields )
-															.merge( local_symbol: "" )
+          leg_prototype  = IB::Option.new from.attributes
+            .slice( :currency, :symbol, :exchange)
+            .merge(defaults)
+            .merge( fields )
 															
-					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
-					the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :put, strike: kind[:p] )
-					the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :call, strike: kind[:c] )
+          leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+          the_spread.add_leg leg_prototype.merge( right: :put, strike: kind[:p] ).verify.first
+          the_spread.add_leg leg_prototype.merge( right: :call, strike: kind[:c] ).verify.first
 					error "Initialisation of Legs failed" if the_spread.legs.size != 2
 					the_spread.description =  the_description( the_spread )
 				end
@@ -88,7 +87,7 @@ module IB
 
 
 			def the_description spread
-			 "<Strangle #{spread.symbol}(#{spread.legs.map(&:strike).join(",")})[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+        "<Strangle #{spread.symbol}(#{spread.legs.map(&:strike).join(",")})[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
 			end
 
       end # class

data/lib/ib/spread_prototypes/vertical.rb

@@ -20,8 +20,8 @@ module IB
 				buy =  master.strike if buy.zero? 
 				sell =  master.strike if sell.zero? 
 				initialize_spread( master ) do | the_spread |
-					the_spread.add_leg master.essential.merge(strike: sell, local_symbol: "", con_id: 0), action: :sell
-					the_spread.add_leg master.essential.merge(strike: buy, local_symbol: "", con_id: 0), action: :buy
+          the_spread.add_leg master.merge(strike: sell).verify.first, action: :sell
+          the_spread.add_leg master.merge(strike: buy).verify.first, action: :buy
 					error "Initialisation of Legs failed" if the_spread.legs.size != 2
 					the_spread.description =  the_description( the_spread )
 				end
@@ -54,16 +54,15 @@ module IB
 											 from
 										 end
 				kind = { :buy => fields.delete(:buy), :sell => fields.delete(:sell) }
-				error "Specifiaction of :buy and :sell nessesary, got: #{kind.inspect}" if kind.values.any?(nil)
+				error "Specification of :buy and :sell necessary, got: #{kind.inspect}" if kind.values.any?(nil)
 				initialize_spread( underlying ) do | the_spread |
-					leg_prototype  = IB::Option.new underlying.attributes
+					leg_prototype  = Option.new underlying.attributes
 															.slice( :currency, :symbol, :exchange)
 															.merge(defaults)
 															.merge( fields )
-															.merge( local_symbol: "" )
 					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
-					the_spread.add_leg  leg_prototype.merge(strike: kind[:sell]), action: :sell
-					the_spread.add_leg  leg_prototype.merge(strike: kind[:buy] ), action: :buy
+          the_spread.add_leg  leg_prototype.merge(strike: kind[:sell]).verify.first, action: :sell
+          the_spread.add_leg  leg_prototype.merge(strike: kind[:buy] ).verify.first, action: :buy
 					error "Initialisation of Legs failed" if the_spread.legs.size != 2
 					the_spread.description =  the_description( the_spread )
 				end

data/lib/ib/verify.rb

@@ -1,6 +1,8 @@
 module IB
 	# define a custom ErrorClass which can be fired if a verification fails
-#	class VerifyError < StandardError
+	class VerifyError < StandardError
+
+  end
 #	end
 
   class Contract
@@ -49,12 +51,15 @@ module IB
     #    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
+      if thread
+        Thread.new { _verify  &b }
+      else
+      _verify   &b
+      end
     end # def
 
     # returns a hash
-    def nessesary_attributes
+    def necessary_attributes
 
       v= { stock:  { currency: 'USD', exchange: 'SMART', symbol: nil},
            option: { currency: 'USD', exchange: 'SMART', right: 'P', expiry: nil, strike: nil, symbol:  nil},
@@ -70,8 +75,9 @@ module IB
     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
+      c= verify.first
+      self.attributes = c.invariant_attributes
+      self.contract_detail = c.contract_detail
       self
     end
 
@@ -88,47 +94,43 @@ module IB
     # if :update is true, the attributes of the Contract itself are adapted
     #
     # otherwise the Contract is untouched
-    def _verify thread: nil , update:,  &b # :nodoc:
+    def _verify  &b # :nodoc:
       ib = Connection.current
+      error "No Connection"  unless ib.is_a? Connection
       # we generate a Request-Message-ID on the fly
-      message_id = nil
+      error "Either con_id or sec_type have to be set", :verify if con_id.to_i.zero?  && sec_type.blank?
       # define local vars which are updated within the query-block
-      recieved_contracts = []
+      received_contracts = []
       queue = Queue.new
-      a = nil
+      message_id = 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 )
+      tws_request_not_necessary = bag? || contract_detail.is_a?( ContractDetail )
 
-      if tws_request_not_nessesary
+      if tws_request_not_necessary
         yield self if block_given?
-        return self
+        return [self]    # return an array!
       else # subscribe to ib-messages and describe what to do
         a = ib.subscribe(:Alert, :ContractData,  :ContractDataEnd) do |msg|
           case msg
           when Messages::Incoming::Alert
+            ## do not throw an error here, asynchronous operation!
+            ## just notice failure in log and return nil instead of contract-object
             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
+              c = if block_given?
+                           yield msg.contract
+                     else
+                           msg.contract
+                   end
+              queue.push c unless c.nil?
             end
           when Messages::Incoming::ContractDataEnd
-            queue.push(1) if  msg.request_id.to_i == message_id
-
+            queue.close if  msg.request_id.to_i == message_id
           end  # case
         end # subscribe
 
@@ -138,19 +140,12 @@ module IB
         #	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
+        while r = queue.pop  
+          received_contracts << r
         end
+        ib.unsubscribe a
       end
+      received_contracts	 # return contracts	
     end
 
     # Generates an IB::Contract with the required attributes to retrieve a unique contract from the TWS
@@ -189,7 +184,7 @@ module IB
         #			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
+        Contract.new  con_id: con_id , :exchange => exchange.presence || item_attributehash[necessary_attributes][:exchange].presence || 'SMART'				# return this
       end  # if
     end # def
   end

data/lib/ib-gateway.rb

@@ -1,5 +1,17 @@
+require "distribution"
+require "polars"
 require  'ib-api'
 require  'ib/verify'
 require  'ib/spread-prototypes'
 require  'ib/order-prototypes'
+require "ib/eod"
+require "ib/market-price"
+require "ib/option-chain"
+require "ib/option-greeks"
+require "ib/models/contract.rb"
+require "ib/models/bag.rb"
+require "ib/models/account.rb"
+require "ib/models/option.rb"
+require "ib/models/future.rb"
+require "ib/probability_of_expiring"
 require  'ib/gateway'