ib-api 972.0

data/lib/ib/messages/incoming/real_time_bar.rb

@@ -0,0 +1,32 @@
+module IB
+  module Messages
+    module Incoming
+
+      # RealTimeBar contains following @data:
+      #    :request_id - The ID of the *request* to which this is responding
+      #    :time - The date-time stamp of the start of the bar. The format is offset in
+      #            seconds from the beginning of 1970, same format as the UNIX epoch time
+      #    :bar - received RT Bar
+      RealTimeBar = def_message [50, 3],
+                                [:request_id, :int],
+                                [:bar, :time, :int_date],
+                                [:bar, :open, :decimal],
+                                [:bar, :high, :decimal],
+                                [:bar, :low, :decimal],
+                                [:bar, :close, :decimal],
+                                [:bar, :volume, :int],
+                                [:bar, :wap, :decimal],
+                                [:bar, :trades, :int]
+      class RealTimeBar
+        def bar
+          @bar = IB::Bar.new @data[:bar]
+        end
+
+        def to_human
+          "<RealTimeBar: #{request_id} #{bar}>"
+        end
+      end # RealTimeBar
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/scanner_data.rb

@@ -0,0 +1,54 @@
+module IB
+  module Messages
+    module Incoming
+
+      # This method receives the requested market scanner data results.
+      # ScannerData contains following @data:
+      # :request_id - The ID of the request to which this row is responding
+      # :count - Number of data points returned (size of :results).
+      # :results - an Array of Hashes, each hash contains a set of
+      #            data about one scanned Contract:
+      #            :contract - a full description of the contract (details).
+      #            :distance - Varies based on query.
+      #            :benchmark - Varies based on query.
+      #            :projection - Varies based on query.
+      #            :legs - Describes combo legs when scan is returning EFP.
+      ScannerData = def_message [20, 3],
+                                [:request_id, :int], # request id
+                                [:count, :int]
+      class ScannerData
+        attr_accessor :results
+				using IBSupport  # extended Array-Class  from abstract_message
+
+        def load
+          super
+
+          @results = Array.new(@data[:count]) do |_|
+            {:rank => buffer.read_int,
+             :contract =>
+                 Contract.build(
+                     :con_id => buffer.read_int,
+                     :symbol => buffer.read_string,
+                     :sec_type => buffer.read_string,
+                     :expiry => buffer.read_string,
+                     :strike => buffer.read_decimal,
+                     :right => buffer.read_string,
+                     :exchange => buffer.read_string,
+                     :currency => buffer.read_string,
+                     :local_symbol => buffer.read_string,
+                     :contract_detail =>
+                         IB::ContractDetail.new(
+                             :market_name => buffer.read_string,
+                             :trading_class => buffer.read_string)),
+             :distance => buffer.read_string,
+             :benchmark => buffer.read_string,
+             :projection => buffer.read_string,
+             :legs => buffer.read_string,
+            }
+          end
+        end
+      end # ScannerData
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/incoming/ticks.rb

@@ -0,0 +1,268 @@
+# All message classes related to ticks located here
+module IB
+  module Messages
+    module Incoming
+
+      class AbstractTick < AbstractMessage
+        # Returns Symbol with a meaningful name for received tick type
+        def type
+          TICK_TYPES[@data[:tick_type]]
+        end
+
+        def to_human
+          "<#{self.message_type} #{type}:" +
+              @data.map do |key, value|
+                " #{key} #{value}" unless [:version, :ticker_id, :tick_type].include?(key)
+              end.compact.join(',') + " >"
+        end
+
+				def the_data
+					@data.reject{|k,_| [:version, :ticker_id].include? k }
+				end
+			end	
+				
+
+      # The IB code seems to dispatch up to two wrapped objects for this message, a tickPrice
+      # and sometimes a tickSize, which seems to be identical to the TICK_SIZE object.
+      #
+      # Important note from
+      # http://chuckcaplan.com/twsapi/index.php/void%20tickPrice%28%29 :
+      #
+      # "The low you get is NOT the low for the day as you'd expect it
+      # to be. It appears IB calculates the low based on all
+      # transactions after 4pm the previous day. The most inaccurate
+      # results occur when the stock moves up in the 4-6pm aftermarket
+      # on the previous day and then gaps open upward in the
+      # morning. The low you receive from TWS can be easily be several
+      # points different from the actual 9:30am-4pm low for the day in
+      # cases like this. If you require a correct traded low for the
+      # day, you can't get it from the TWS API. One possible source to
+      # help build the right data would be to compare against what Yahoo
+      # lists on finance.yahoo.com/q?s=ticker under the "Day's Range"
+      # statistics (be careful here, because Yahoo will use anti-Denial
+      # of Service techniques to hang your connection if you try to
+      # request too many bytes in a short period of time from them). For
+      # most purposes, a good enough approach would start by replacing
+      # the TWS low for the day with Yahoo's day low when you first
+      # start watching a stock ticker; let's call this time T. Then,
+      # update your internal low if the bid or ask tick you receive is
+      # lower than that for the remainder of the day. You should check
+      # against Yahoo again at time T+20min to handle the occasional
+      # case where the stock set a new low for the day in between
+      # T-20min (the real time your original quote was from, taking into
+      # account the delay) and time T. After that you should have a
+      # correct enough low for the rest of the day as long as you keep
+      # updating based on the bid/ask. It could still get slightly off
+      # in a case where a short transaction setting a new low appears in
+      # between ticks of data that TWS sends you.  The high is probably
+      # distorted in the same way the low is, which would throw your
+      # results off if the stock traded after-hours and gapped down. It
+      # should be corrected in a similar way as described above if this
+      # is important to you."
+      #
+      # IB then emits at most 2 events on eWrapper:
+      #          tickPrice( tickerId, tickType, price, canAutoExecute)
+      #          tickSize( tickerId, sizeTickType, size)
+      TickPrice = def_message [1, 6], AbstractTick,
+                              [:ticker_id, :int],
+                              [:tick_type, :int],
+                              [:price, :float],
+                              [:size, :int],
+                              [:can_auto_execute, :int]
+			class TickPrice
+				def valid?
+				super &&	!price.zero?
+				end
+			end
+
+      TickSize = def_message [2, 6], AbstractTick,
+                             [:ticker_id, :int],
+                             [:tick_type, :int],
+                             [:size, :int]
+
+      TickGeneric = def_message [45, 6], AbstractTick,
+                                [:ticker_id, :int],
+                                [:tick_type, :int],
+                                [:value, :decimal]
+
+      TickString = def_message [46, 6], AbstractTick,
+                               [:ticker_id, :int],
+                               [:tick_type, :int],
+                               [:value, :string]
+
+      TickEFP = def_message [47, 6], AbstractTick,
+                            [:ticker_id, :int],
+                            [:tick_type, :int],
+                            [:basis_points, :decimal],
+                            [:formatted_basis_points, :string],
+                            [:implied_futures_price, :decimal],
+                            [:hold_days, :int],
+                            [:dividend_impact, :decimal],
+                            [:dividends_to_expiry, :decimal]
+
+      # This message is received when the market in an option or its underlier moves.
+      # TWS option model volatilities, prices, and deltas, along with the present
+      # value of dividends expected on that options underlier are received.
+      # TickOption message contains following @data:
+      #    :ticker_id - Id that was specified previously in the call to reqMktData()
+      #    :tick_type - Specifies the type of option computation (see TICK_TYPES).
+      #    :implied_volatility - The implied volatility calculated by the TWS option
+      #                          modeler, using the specified :tick_type value.
+      #    :delta - The option delta value.
+      #    :option_price - The option price.
+      #    :pv_dividend - The present value of dividends expected on the options underlier
+      #    :gamma - The option gamma value.
+      #    :vega - The option vega value.
+      #    :theta - The option theta value.
+      #    :under_price - The price of the underlying.
+      TickOptionComputation = TickOption =
+          def_message([21, 6], AbstractTick,
+                      [:ticker_id, :int],
+                      [:tick_type, :int],
+                      #                       What is the "not yet computed" indicator:
+                      [:implied_volatility, :decimal_limit_1], # -1 and below
+                      [:delta, :decimal_limit_2],					#      -2 and below
+                      [:option_price, :decimal_limit_1],	#      -1   -"-
+                      [:pv_dividend, :decimal_limit_1],		#      -1   -"-
+                      [:gamma, :decimal_limit_2],					#      -2   -"-
+                      [:vega, :decimal_limit_2],					#      -2   -"-
+                      [:theta, :decimal_limit_2],					#      -2   -"-
+                      [:under_price, :decimal_limit_1]) do
+
+            "<TickOption #{type} for #{ticker_id}: underlying @ #{under_price}, "+
+                "option @ #{option_price}, IV #{implied_volatility}%, delta #{delta}, " +
+                "gamma #{gamma}, vega #{vega}, theta #{theta}, pv_dividend #{pv_dividend}>"
+          end
+
+      TickSnapshotEnd = def_message 57, [:ticker_id, :int]
+=begin
+    def processTickByTickMsg(self, fields):
+        next(fields)
+        reqId = decode(int, fields)
+        tickType = decode(int, fields)
+        time = decode(int, fields)
+
+        if tickType == 0:
+            # None
+            pass
+        elif tickType == 1 or tickType == 2:
+            # Last or AllLast
+            price = decode(float, fields)
+            size = decode(int, fields)
+            mask = decode(int, fields)
+class TickAttribLast(Object):
+    def __init__(self):
+        self.pastLimit = False
+        self.unreported = False
+
+    def __str__(self):
+        return "PastLimit: %d, Unreported: %d" % (self.pastLimit, self.unreported)
+
+            tickAttribLast = TickAttribLast()
+            tickAttribLast.pastLimit = mask & 1 != 0
+            tickAttribLast.unreported = mask & 2 != 0
+            exchange = decode(str, fields)
+            specialConditions = decode(str, fields)
+
+            self.wrapper.tickByTickAllLast(reqId, tickType, time, price, size, tickAttribLast,
+                                           exchange, specialConditions)
+        elif tickType == 3:
+            # BidAsk
+            bidPrice = decode(float, fields)
+            askPrice = decode(float, fields)
+            bidSize = decode(int, fields)
+            askSize = decode(int, fields)
+            mask = decode(int, fields)
+	class TickAttribBidAsk(Object):
+    def __init__(self):
+        self.bidPastLow = False
+        self.askPastHigh = False
+
+    def __str__(self):
+        return "BidPastLow: %d, AskPastHigh: %d" % (self.bidPastLow, self.askPastHigh)
+
+
+            tickAttribBidAsk = TickAttribBidAsk()
+            tickAttribBidAsk.bidPastLow = mask & 1 != 0
+            tickAttribBidAsk.askPastHigh = mask & 2 != 0
+
+            self.wrapper.tickByTickBidAsk(reqId, time, bidPrice, askPrice, bidSize,
+                                          askSize, tickAttribBidAsk)
+        elif tickType == 4:
+            # MidPoint
+            midPoint = decode(float, fields)
+
+            self.wrapper.tickByTickMidPoint(reqId, time, midPoint)
+=end
+			TickByTick =  def_message [99, 0], [:ticker_id, :int ],
+			[ :tick_type, :int],
+			[ :time, :int_date ]
+
+			## error messages: (10189) "Failed to request tick-by-tick data:Historical data request pacing violation"
+			#  
+			class TickByTick
+				using IBSupport  # extended Array-Class  from abstract_message
+				
+				def resolve_mask
+					@data[:mask].present? ? [ @data[:mask] & 1 , @data[:mask] & 2  ] : [] 
+				end
+
+				def load
+					super
+					case @data[:tick_type ] 
+											when 0
+												# do nothing
+											when 1, 2 # Last, AllLast
+							load_map	[ :price, :decimal ]	,
+												[ :size, :int ] ,
+												[ :mask, :int ]	,  		
+												[ :exchange, :string ], 
+												[ :special_conditions, :string ]
+											when 3  # bid/ask
+							load_map  [ :bid_price, :decimal ],
+												[ :ask_price, :decimal],
+												[ :bid_size, :int ],
+												[ :ask_size, :int] ,
+												[ :mask, :int  ]	
+											when 4
+							load_map	[ :mid_point, :decimal ]
+											end
+
+					@out_labels = case @data[ :tick_tpye ]
+											when 1, 2
+												[ "PastLimit", "Unreported" ]
+												when 3 
+												[ "BitPastLow", "BidPastHigh" ]
+												else
+													[]
+												end	
+				end 
+				def to_human
+					"< TickByTick:" + 	case @data[ :tick_type ]
+					when 1,2
+						"(Last) #{size} @ #{price} [#{exchange}] "
+					when 3
+						"(Bid/Ask) #{bid_size} @ #{bid_price} / #{ask_size } @ #{ask_price} "
+					when 4
+						"(Midpoint)  #{mid_point } "
+					else
+						""
+					end +  @out_labels.zip(resolve_mask).join( "/" )
+				end
+
+				[:price, :size, :mask, :exchange, :specialConditions, :bid_price, :ask_price, :bid_size, :ask_size, :mid_point].each do |name|
+					define_method name do
+						@data[name]
+					end
+				end
+			#	def method_missing method, *args
+			#		if @data.keys.include? method
+			#			@data[method]
+			#		else
+			#			error "method #{method} not known"
+			#		end
+			#	end
+			end
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib/messages/outgoing.rb

@@ -0,0 +1,437 @@
+require 'ib/messages/outgoing/abstract_message'
+
+# TODO: Don't instantiate messages, use their classes as just namespace for .encode/decode
+
+module IB
+  module Messages
+
+    # Outgoing IB messages (sent to TWS/Gateway)
+    module Outgoing
+      extend Messages # def_message macros
+
+      ### Defining (short) Outgoing Message classes for IB:
+
+      ## Empty messages (no data)
+
+      # Request the open orders that were placed from THIS client. Each open order
+      # will be fed back through the OpenOrder and OrderStatus messages ONCE.
+      # NB: Client with a client_id of 0 will also receive the TWS-owned open orders.
+      # These orders will be associated with the client and a new orderId will be
+      # generated. This association will persist over multiple API and TWS sessions.
+      RequestOpenOrders = def_message 5
+
+      # Request the open orders placed from all clients and also from TWS. Each open
+      # order will be fed back through the OpenOrder and OrderStatus messages ONCE.
+      # Note this does not re-bind those Orders to requesting Client!
+      # Use RequestAutoOpenOrders to request such re-binding.
+      RequestAllOpenOrders = def_message 16
+
+      # Request that newly created TWS orders be implicitly associated with this client.
+      # When a new TWS order is created, the order will be associated with this client
+      # and automatically fed back through the OpenOrder and OrderStatus messages.
+      # It is a 'continuous' request such that it gets turned 'on' when called with a
+      # TRUE auto_bind parameter. When it's called with FALSE auto_bind, new TWS orders
+      # will not bind to this client going forward. Note that TWS orders can only be
+      # bound to clients with a client_id of 0. TODO: how to properly test this?
+      # data = { :auto_bind => boolean }
+      RequestAutoOpenOrders = def_message 15, :auto_bind
+
+      # Requests an XML document that describes the valid parameters that a scanner
+      # subscription can have (for outgoing RequestScannerSubscription message).
+      RequestScannerParameters = def_message 24
+
+		  RequestNewsArticle = def_message 84,
+				 :request_id , # autogenerated
+				 :provider_code,
+				 :article_id,
+				 :options  # taglist
+
+
+			RequestNewsProviders =  def_message 85   # no further parameters
+			RequestHistoricalNews =  def_message 86,
+				 :request_id , # autogenerated
+				 :con_id,
+				 :provider_code,
+				 :start,      # date
+				 :total_results,
+				 :options  # taglist
+
+
+      CancelNewsBulletins = def_message 13
+      RequestCurrentTime = def_message 49
+      RequestGlobalCancel = def_message 58
+
+      ## Data format is: @data = { :id => ticker_id}
+      CancelMarketData = def_message [2, 2]
+      CancelMarketDepth = def_message 11
+      CancelScannerSubscription = def_message 23
+      CancelHistoricalData = def_message 25
+      CancelRealTimeBars = def_message 51
+
+      ## Data format is: @data = { :id => request_id }
+      CancelFundamentalData = def_message 53
+      CancelCalculateImpliedVolatility = CancelImpliedVolatility = def_message 56
+      CancelCalculateOptionPrice = CancelOptionPrice = def_message 57
+
+      ## Data format is: @data ={ :id => local_id of order to cancel }
+      CancelOrder = def_message 4
+
+      # Request the next valid ID that can be used when placing an order. Responds with
+      # NextValidId message, and the id returned is that next valid Id for orders.
+      # That ID will reflect any autobinding that has occurred (which generates new
+      # IDs and increments the next valid ID therein).
+      # @data = { :number of ids requested => int } NB: :number option is ignored by TWS!
+      RequestIds = def_message 8, [:number, 1]
+      # data = { :all_messages => boolean }
+      RequestNewsBulletins = def_message 12, :all_messages
+      # data = { :log_level => int }
+      SetServerLoglevel = def_message 14, :log_level
+      # data = { :fa_data_type => int }  1 -> groups, 2 -> Profiles, 3 -> Account Aliases
+      RequestFA = def_message 18, :fa_data_type
+      # data = { :fa_data_type => int, :xml => String }
+      ReplaceFA = def_message 19, :fa_data_type, :xml
+      # data = { :market_data_type => int }
+
+
+      # data => { :id => request_id (int), :contract => Contract }
+      #
+      # Special case for options: "wildcards" in the Contract fields retrieve Option chains
+      #   strike = 0 means all strikes
+      #   right = "" meanns both call and put
+      #   expiry = "" means all expiries
+      #   expiry = "2013" means all expiries in 2013
+      #   expiry = "201311" means all expiries in Nov 2013
+      # You'll get several ContractData (10) messages back if there is more than one match.
+      # When all the matches are delivered you'll get ContractDataEnd (52) message.
+      RequestContractDetails = RequestContractData =
+          def_message([9, 8], :request_id , # autogenerated
+                      [:contract, :serialize_long, [:sec_id_type]])
+	
+			# Requests security definition option parameters for viewing a contract's option chain 
+			#  request_id:   The ID chosen for the request
+      #  underlyingSymbol 
+			#  futFopExchange:  The exchange on which the returned options are trading. 
+			#										Can be set to the empty string "" for all exchanges. 
+			#  underlyingSecType: The type of the underlying security, i.e. STK 
+			#  underlyingConId: the contract ID of the underlying security.
+			#  con_id:	
+      #  Responses via Messages::Incoming::SecurityDefinitionOptionParameter
+
+
+			RequestSecurityDefinitionOptionParameters = ReqSecDefOptParams  = RequestOptionChainDefinition = def_message [78,0],
+																	:request_id,   # autogenerated if not specified
+																	:symbol,				# underlyingSymbol
+																	[:exchange, ""],			# futOptExchange
+																	:sec_type,			# underlyingSecType
+																	:con_id					# underlyingConId  (required)
+																	
+      # data = { :id => ticker_id (int), :contract => Contract, :num_rows => int }
+
+
+#			Requests venues for which market data is returned to updateMktDepthL2
+			#			returns MarketDepthExchanges-Message
+			#
+      RequestMarketDepthExchanges =			# requires ServerVersion >= 112
+		 	   def_message 82
+
+ 
+			## actual Version supported is: 137 
+			## changes:   MIN_SERVER_VER_SMART_DEPTH: 146  --> insert 'is_smarth_depth' after 'num_rows'
+			##  then: 'is_smart_depth' (bool) has to be specified in  CancelMarketDepth, too
+			#
+      RequestMarketDepth = def_message([10, 5],
+																	:request_id,   # autogenerated if not specified
+                                       [:contract, :serialize_supershort ],
+                                       :num_rows, 
+				       "")  #  mktDataOptionsStr. ## not supported by api
+
+      # When this message is sent, TWS responds with ExecutionData messages, each
+      # containing the execution report that meets the specified criteria.
+      # @data={:id =>         int: :request_id,
+      #        :client_id => int: Filter the results based on the clientId.
+      #        :account => Filter the results based on based on account code.
+      #                      Note: this is only relevant for Financial Advisor accts.
+      #        :sec_type =>  Filter the results based on the order security type.
+      #        :time =>      Filter the results based on execution reports received
+      #                      after the specified time - format "yyyymmdd-hh:mm:ss"
+      #        :symbol   =>  Filter the results based on the order symbol.
+      #        :exchange =>  Filter the results based on the order exchange
+      #        :side =>  Filter the results based on the order action: BUY/SELL/SSHORT
+      RequestExecutions = def_message([7, 3],
+																			 :request_id,  # autogenerated if not specified
+                                      :client_id,
+                                      :account,
+                                      :time, # Format "yyyymmdd-hh:mm:ss"
+                                      :symbol,
+                                      :sec_type,
+                                      :exchange,
+                                      :side)
+
+      # data = { :id => ticker_id (int),
+      #          :contract => IB::Contract,
+      #          :exercise_action => int, 1 = exercise, 2 = lapse
+      #          :exercise_quantity => int, The number of contracts to be exercised
+      #          :account => string,
+      #          :override => int: Specifies whether your setting will override the
+      #                       system's natural action. For example, if your action
+      #                       is "exercise" and the option is not in-the-money, by
+      #                       natural action the option would not exercise. If you
+      #                       have override set to "yes" the natural action would be
+      #                       overridden and the out-of-the money option would be
+      #                       exercised. Values are:
+      #                              - 0 = do not override
+      #                              - 1 = override
+      ExerciseOptions = def_message([ 21, 2 ],  
+																	#		:request_id, # id -> required  # todo : TEST
+                                    [:contract, :serialize_short],
+                                    :exercise_action,
+                                    :exercise_quantity,
+                                    :account,
+                                    :override)
+
+
+      # The API can receive frozen market data from Trader Workstation. Frozen market
+      # data is the last data recorded in our system. During normal trading hours,
+      # the API receives real-time market data. If you use this function, you are
+      # telling TWS to automatically switch to frozen market data AFTER the close.
+      # Then, before the opening of the next trading day, market data will automatically
+      # switch back to real-time market data.
+      # :market_data_type = 1 (:real_time) for real-time streaming, 2 (:frozen) for frozen market data
+			#										= 3 (:delayed) for delayed streaming , 4 (:frozen_delayed)  for frozen delayed
+      RequestMarketDataType =
+          def_message 59, [:market_data_type,
+                           lambda { |type| MARKET_DATA_TYPES.invert[type] || type }, []]
+
+      # Send this message to receive Reuters global fundamental data. There must be
+      # a subscription to Reuters Fundamental set up in Account Management before
+      # you can receive this data.
+      # data = { :id => int: :request_id,
+      #          :contract => Contract,
+      #          :report_type => String: one of the following:
+      #                   'estimates' - Estimates
+      #                   'finstat'   - Financial statements
+      #                    'snapshot' - Summary   }a
+			#                    ReportsFinSummary	Financial summary
+			#ReportsOwnership	Company's ownership (Can be large in size)
+			#ReportSnapshot	Company's financial overview
+			#ReportsFinStatements	Financial Statements
+			#RESC	Analyst Estimates
+			#CalendarReport	Company's calendar 
+      RequestFundamentalData =
+          def_message([52,2],
+                     :request_id, # autogenerated if not specified
+											 [:contract, :serialize, :primary_exchange],
+                      :report_type,
+											""  )
+
+			# Returns the timestamp of earliest available historical data for a contract and data type. 
+					#  :what_to_show: type of data for head timestamp - "BID", "ASK", "TRADES", etc 
+					#  :use_rth     : use regular trading hours only, 1 for yes or 0 for no 
+					#  format_data	: set to 2 to obtain it like system time format in second ---> don't change
+			RequestHeadTimeStamp = 
+					def_message( [87,0], 	:request_id, # autogenerated
+					[:contract, :serialize_short, [:primary_exchange,:include_expired] ],
+					[:use_rth, 1 ],
+					[:what_to_show, 'Trades' ],
+					[:format_date, 2 ]  )    ## don't change!
+
+			CancelHeadTimeStamp =
+					def_message [90,0 ] # , :(request_)id #required
+
+
+
+			RequestHistogramData = 
+					def_message( [88, 0],  :request_id, #  autogenerated
+					[:contract, :serialize_short, [:primary_exchange,:include_expired] ],
+					[:use_rth, 1 ],
+					[:time_period ]   )
+
+			CancelHistogramData =
+					def_message [89,0 ] # , :(request_)id  required
+
+      RequestCalculateImpliedVolatility = CalculateImpliedVolatility =
+          RequestImpliedVolatility =
+              def_message([ 54,3 ],:request_id,  # autogenerated
+                      [:contract, :serialize_short, :primary_exchange],
+                          :option_price,
+                          :under_price,
+													[:implied_volatility_options_count, 0],
+												  [:implied_volatility_options_conditions, ''])
+
+      # data = { :request_id => int, :contract => Contract,
+      #          :volatility => double, :under_price => double }
+      RequestCalculateOptionPrice = CalculateOptionPrice = RequestOptionPrice =
+          def_message([ 55, 3], :request_id, #autogenerated if not specified
+                      [:contract, :serialize_short, :primary_exchange],
+                      :volatility,
+                      :under_price,
+													[:implied_volatility_options_count, 0],
+												  [:implied_volatility_options_conditions, ''])
+
+      # Start receiving market scanner results through the ScannerData messages.
+      # @data = { :id => ticker_id (int),
+      #  :number_of_rows => int: number of rows of data to return for a query.
+      #  :instrument => The instrument type for the scan. Values include
+      #                                'STK', - US stocks
+      #                                'STOCK.HK' - Asian stocks
+      #                                'STOCK.EU' - European stocks
+      #  :location_code => Legal Values include:
+      #                           - STK.US - US stocks
+      #                           - STK.US.MAJOR - US stocks (without pink sheet)
+      #                           - STK.US.MINOR - US stocks (only pink sheet)
+      #                           - STK.HK.SEHK - Hong Kong stocks
+      #                           - STK.HK.ASX - Australian Stocks
+      #                           - STK.EU - European stocks
+      #  :scan_code => The type of the scan, such as HIGH_OPT_VOLUME_PUT_CALL_RATIO.
+      #  :above_price => double: Only contracts with a price above this value.
+      #  :below_price => double: Only contracts with a price below this value.
+      #  :above_volume => int: Only contracts with a volume above this value.
+      #  :market_cap_above => double: Only contracts with a market cap above this
+      #  :market_cap_below => double: Only contracts with a market cap below this value.
+      #  :moody_rating_above => Only contracts with a Moody rating above this value.
+      #  :moody_rating_below => Only contracts with a Moody rating below this value.
+      #  :sp_rating_above => Only contracts with an S&P rating above this value.
+      #  :sp_rating_below => Only contracts with an S&P rating below this value.
+      #  :maturity_date_above => Only contracts with a maturity date later than this
+      #  :maturity_date_below => Only contracts with a maturity date earlier than this
+      #  :coupon_rate_above => double: Only contracts with a coupon rate above this
+      #  :coupon_rate_below => double: Only contracts with a coupon rate below this
+      #  :exclude_convertible => Exclude convertible bonds.
+      #  :scanner_setting_pairs => Used with the scan_code to help further narrow your query.
+      #                            Scanner Setting Pairs are delimited by slashes, making
+      #                            this parameter open ended. Example is "Annual,true" -
+      #                            when used with 'Top Option Implied Vol % Gainers' scan
+      #                            would return annualized volatilities.
+      #  :average_option_volume_above =>  int: Only contracts with average volume above this
+      #  :stock_type_filter => Valid values are:
+      #                          'ALL' (excludes nothing)
+      #                          'STOCK' (excludes ETFs)
+      #                          'ETF' (includes ETFs) }
+      # ------------
+      # To learn all valid parameter values that a scanner subscription can have,
+      # first subscribe to ScannerParameters and send RequestScannerParameters message.
+      # Available scanner parameters values will be listed in received XML document.
+      RequestScannerSubscription =
+          def_message([22, 3], :request_id , 
+                      [:number_of_rows, -1], # was: EOL,
+                      :instrument,
+                      :location_code,
+                      :scan_code,
+                      :above_price,
+                      :below_price,
+                      :above_volume,
+                      :market_cap_above,
+                      :market_cap_below,
+                      :moody_rating_above,
+                      :moody_rating_below,
+                      :sp_rating_above,
+                      :sp_rating_below,
+                      :maturity_date_above,
+                      :maturity_date_below,
+                      :coupon_rate_above,
+                      :coupon_rate_below,
+                      :exclude_convertible,
+                      :average_option_volume_above, # ?
+                      :scanner_setting_pairs,
+                      :stock_type_filter)
+
+
+										  
+      require 'ib/messages/outgoing/place_order'
+      require 'ib/messages/outgoing/bar_requests'
+      require 'ib/messages/outgoing/account_requests'
+      require 'ib/messages/outgoing/request_marketdata'
+      require 'ib/messages/outgoing/request_tick_data'
+
+    end # module Outgoing
+  end # module Messages
+end # module IB
+
+__END__
+## python: message.py
+     REQ_MKT_DATA                  = 1
+     CANCEL_MKT_DATA               = 2
+     PLACE_ORDER                   = 3
+     CANCEL_ORDER                  = 4
+     REQ_OPEN_ORDERS               = 5
+     REQ_ACCT_DATA                 = 6
+     REQ_EXECUTIONS                = 7
+     REQ_IDS                       = 8
+     REQ_CONTRACT_DATA             = 9
+     REQ_MKT_DEPTH                 = 10
+     CANCEL_MKT_DEPTH              = 11
+     REQ_NEWS_BULLETINS            = 12
+     CANCEL_NEWS_BULLETINS         = 13
+     SET_SERVER_LOGLEVEL           = 14
+     REQ_AUTO_OPEN_ORDERS          = 15
+     REQ_ALL_OPEN_ORDERS           = 16
+     REQ_MANAGED_ACCTS             = 17
+     REQ_FA                        = 18
+     REPLACE_FA                    = 19
+     REQ_HISTORICAL_DATA           = 20
+     EXERCISE_OPTIONS              = 21
+     REQ_SCANNER_SUBSCRIPTION      = 22
+     CANCEL_SCANNER_SUBSCRIPTION   = 23
+     REQ_SCANNER_PARAMETERS        = 24
+     CANCEL_HISTORICAL_DATA        = 25
+     REQ_CURRENT_TIME              = 49
+     REQ_REAL_TIME_BARS            = 50
+     CANCEL_REAL_TIME_BARS         = 51
+     REQ_FUNDAMENTAL_DATA          = 52
+     CANCEL_FUNDAMENTAL_DATA       = 53
+     REQ_CALC_IMPLIED_VOLAT        = 54
+     REQ_CALC_OPTION_PRICE         = 55
+     CANCEL_CALC_IMPLIED_VOLAT     = 56
+     CANCEL_CALC_OPTION_PRICE      = 57
+     REQ_GLOBAL_CANCEL             = 58
+     REQ_MARKET_DATA_TYPE          = 59  --> supported by ib-ruby 0.94
+     
+     REQ_POSITIONS                 = 61   supported now
+     REQ_ACCOUNT_SUMMARY           = 62   supported now
+
+     CANCEL_ACCOUNT_SUMMARY        = 63   supported now
+
+     CANCEL_POSITIONS              = 64   supported now
+     VERIFY_REQUEST                = 65
+     VERIFY_MESSAGE                = 66
+     QUERY_DISPLAY_GROUPS          = 67
+     SUBSCRIBE_TO_GROUP_EVENTS     = 68
+     UPDATE_DISPLAY_GROUP          = 69
+     UNSUBSCRIBE_FROM_GROUP_EVENTS = 70
+     START_API                     = 71
+     VERIFY_AND_AUTH_REQUEST       = 72
+     VERIFY_AND_AUTH_MESSAGE       = 73
+     REQ_POSITIONS_MULTI           = 74   supported now
+     CANCEL_POSITIONS_MULTI        = 75   supported now
+
+     REQ_ACCOUNT_UPDATES_MULTI     = 76   supported now
+
+     CANCEL_ACCOUNT_UPDATES_MULTI  = 77   supported now
+
+     REQ_SEC_DEF_OPT_PARAMS        = 78   supported now
+     REQ_SOFT_DOLLAR_TIERS         = 79
+     REQ_FAMILY_CODES              = 80
+     REQ_MATCHING_SYMBOLS          = 81
+     REQ_MKT_DEPTH_EXCHANGES       = 82
+     REQ_SMART_COMPONENTS          = 83
+     REQ_NEWS_ARTICLE              = 84  in preparation
+     REQ_NEWS_PROVIDERS            = 85		in preparatino
+     REQ_HISTORICAL_NEWS           = 86 in preparation
+
+     REQ_HEAD_TIMESTAMP            = 87   supported now
+
+     REQ_HISTOGRAM_DATA            = 88   supported now
+
+     CANCEL_HISTOGRAM_DATA         = 89   supported now
+
+     CANCEL_HEAD_TIMESTAMP         = 90   supported now
+
+     REQ_MARKET_RULE               = 91
+     REQ_PNL                       = 92
+     CANCEL_PNL                    = 93
+     REQ_PNL_SINGLE                = 94
+     CANCEL_PNL_SINGLE             = 95
+     REQ_HISTORICAL_TICKS          = 96
+     REQ_TICK_BY_TICK_DATA         = 97
+     CANCEL_TICK_BY_TICK_DATA      = 98
+