ib-ruby 0.6.1 → 0.7.0

data/lib/ib-ruby/messages/incoming/open_order.rb

@@ -0,0 +1,193 @@
+# OpenOrder is the longest message with complex processing logics, it is isolated here
+module IB
+  module Messages
+    module Incoming
+
+      OpenOrder =
+          def_message [5, [23, 28]],
+                      [:order, :order_id, :int],
+
+                      [:contract, :con_id, :int],
+                      [:contract, :symbol, :string],
+                      [:contract, :sec_type, :string],
+                      [:contract, :expiry, :string],
+                      [:contract, :strike, :decimal],
+                      [:contract, :right, :string],
+                      [:contract, :exchange, :string],
+                      [:contract, :currency, :string],
+                      [:contract, :local_symbol, :string],
+
+                      [:order, :action, :string],
+                      [:order, :total_quantity, :int],
+                      [:order, :order_type, :string],
+                      [:order, :limit_price, :decimal_max],
+                      [:order, :aux_price, :decimal_max],
+                      [:order, :tif, :string],
+                      [:order, :oca_group, :string],
+                      [:order, :account, :string],
+                      [:order, :open_close, :string],
+                      [:order, :origin, :int],
+                      [:order, :order_ref, :string],
+                      [:order, :client_id, :int],
+                      [:order, :perm_id, :int],
+                      [:order, :outside_rth, :boolean], # (@socket.read_int == 1)
+                      [:order, :hidden, :boolean], # (@socket.read_int == 1)
+                      [:order, :discretionary_amount, :decimal],
+                      [:order, :good_after_time, :string],
+                      [:shares_allocation, :string], # deprecated! field
+
+                      [:order, :fa_group, :string],
+                      [:order, :fa_method, :string],
+                      [:order, :fa_percentage, :string],
+                      [:order, :fa_profile, :string],
+                      [:order, :good_till_date, :string],
+                      [:order, :rule_80a, :string],
+                      [:order, :percent_offset, :decimal_max],
+                      [:order, :settling_firm, :string],
+                      [:order, :short_sale_slot, :int],
+                      [:order, :designated_location, :string],
+                      [:order, :exempt_code, :int], # skipped in ver 51?
+                      [:order, :auction_strategy, :int],
+                      [:order, :starting_price, :decimal_max],
+                      [:order, :stock_ref_price, :decimal_max],
+                      [:order, :delta, :decimal_max],
+                      [:order, :stock_range_lower, :decimal_max],
+                      [:order, :stock_range_upper, :decimal_max],
+                      [:order, :display_size, :int],
+                      #@order.rth_only = @socket.read_boolean
+                      [:order, :block_order, :boolean],
+                      [:order, :sweep_to_fill, :boolean],
+                      [:order, :all_or_none, :boolean],
+                      [:order, :min_quantity, :int_max],
+                      [:order, :oca_type, :int],
+                      [:order, :etrade_only, :boolean],
+                      [:order, :firm_quote_only, :boolean],
+                      [:order, :nbbo_price_cap, :decimal_max],
+                      [:order, :parent_id, :int],
+                      [:order, :trigger_method, :int],
+                      [:order, :volatility, :decimal_max],
+                      [:order, :volatility_type, :int],
+                      [:order, :delta_neutral_order_type, :string],
+                      [:order, :delta_neutral_aux_price, :decimal_max]
+
+
+      class OpenOrder
+
+        def load
+          super
+
+          load_map [27, [proc { | | filled?(@data[:order][:delta_neutral_order_type]) },
+                         # As of client v.52, we receive delta... params in openOrder
+                         [:order, :delta_neutral_con_id, :int],
+                         [:order, :delta_neutral_settling_firm, :string],
+                         [:order, :delta_neutral_clearing_account, :string],
+                         [:order, :delta_neutral_clearing_intent, :string]]
+                   ],
+                   [:order, :continuous_update, :int],
+                   [:order, :reference_price_type, :int],
+                   [:order, :trail_stop_price, :decimal_max],
+
+                   # As of client v.56, we receive trailing_percent in openOrder
+                   [30, [:order, :trailing_percent, :decimal_max]], # Never! 28 currently
+
+                   [:order, :basis_points, :decimal_max],
+                   [:order, :basis_points_type, :int_max],
+                   [:contract, :legs_description, :string],
+
+                   # Never happens! 28 is the max supported version currently
+                   # As of client v.55, we receive orderComboLegs (price) in openOrder
+                   [29, [:contract, :legs, :array, proc do |_|
+                     Models::ComboLeg.new :con_id => socket.read_int,
+                                          :ratio => socket.read_int,
+                                          :action => socket.read_string,
+                                          :exchange => socket.read_string,
+                                          :open_close => socket.read_int,
+                                          :short_sale_slot => socket.read_int,
+                                          :designated_location => socket.read_string,
+                                          :exempt_code => socket.read_int
+                   end],
+
+                    # Order keeps received leg prices in a separate Array for some reason ?!
+                    [:order, :leg_prices, :array, proc { |_| socket.read_decimal_max }],
+                   ],
+                   # As of client v.51, we can receive smartComboRoutingParams in openOrder
+                   [26, [:smart_combo_routing_params, :hash]],
+
+                   [:order, :scale_init_level_size, :int_max],
+                   [:order, :scale_subs_level_size, :int_max],
+                   [:order, :scale_price_increment, :decimal_max],
+
+                   # As of client v.54, we can receive scale order fields
+                   [28, [proc { | | filled?(@data[:order][:scale_price_increment]) },
+                         [:order, :scale_price_adjust_value, :decimal_max],
+                         [:order, :scale_price_adjust_interval, :int_max],
+                         [:order, :scale_profit_offset, :decimal_max],
+                         [:order, :scale_auto_reset, :boolean],
+                         [:order, :scale_init_position, :int_max],
+                         [:order, :scale_init_position, :int_max],
+                         [:order, :scale_init_fill_qty, :decimal_max],
+                         [:order, :scale_random_percent, :boolean]]
+                   ],
+
+                   # As of client v.49/50, we can receive hedgeType, hedgeParam, optOutSmartRouting
+                   [25,
+                    [:order, :hedge_type, :string],
+                    [proc { | | filled?(@data[:order][:hedge_type]) },
+                     [:order, :hedge_param, :string],
+                    ],
+                    [:order, :opt_out_smart_routing, :boolean]
+                   ],
+
+                   [:order, :clearing_account, :string],
+                   [:order, :clearing_intent, :string],
+                   [:order, :not_held, :boolean],
+                   [:contract, :under_comp, :boolean],
+
+                   [proc { | | filled?(@data[:contract][:under_comp]) },
+                    [:contract, :under_con_id, :int],
+                    [:contract, :under_delta, :decimal],
+                    [:contract, :under_price, :decimal]
+                   ],
+
+                   [:order, :algo_strategy, :string],
+
+                   # TODO: Test Order with algo_params, scale and legs!
+                   [proc { | | filled?(@data[:order][:algo_strategy]) },
+                    [:order, :algo_params, :hash]
+                   ],
+
+                   [:order, :what_if, :boolean],
+                   [:order, :status, :string],
+                   [:order, :init_margin, :string],
+                   [:order, :maint_margin, :string],
+                   [:order, :equity_with_loan, :string],
+                   [:order, :commission, :decimal_max], # May be nil!
+                   [:order, :min_commission, :decimal_max], # May be nil!
+                   [:order, :max_commission, :decimal_max], # May be nil!
+                   [:order, :commission_currency, :string],
+                   [:order, :warning_text, :string]
+
+          @order = Models::Order.new @data[:order]
+          @contract = Models::Contract.build @data[:contract]
+        end
+
+        # Check if given value was set by TWS to something vaguely "positive"
+        def filled? value
+          case value
+            when String
+              !value.empty?
+            when Float, Integer
+              value > 0
+            else
+              !!value # to_bool
+          end
+        end
+
+        def to_human
+          "<OpenOrder: #{@contract.to_human} #{@order.to_human}>"
+        end
+
+      end # class OpenOrder
+    end # module Incoming
+  end # module Messages
+end # module IB

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

@@ -0,0 +1,131 @@
+# 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
+      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, :decimal],
+                              [:size, :int],
+                              [:can_auto_execute, :int]
+
+      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�s 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]
+
+    end # module Incoming
+  end # module Messages
+end # module IB

data/lib/ib-ruby/messages/outgoing.rb

@@ -1,17 +1,17 @@
 require 'ib-ruby/messages/abstract_message'
 
-# EClientSocket.java uses sendMax() rather than send() for a number of these.
-# It sends an EOL rather than a number if the value == Integer.MAX_VALUE (or Double.MAX_VALUE).
-# These fields are initialized to this MAX_VALUE.
-# This has been implemented with nils in Ruby to represent the case where an EOL should be sent.
-
 # 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
 
+      # Container for specific message classes, keyed by their message_ids
+      Classes = {}
+
       class AbstractMessage < IB::Messages::AbstractMessage
 
         def initialize data={}
@@ -28,21 +28,16 @@ module IB
         # an Array of elements that ought to be sent to the server by calling to_s on
         # each one and postpending a '\0'.
         #
-        def send_to(server)
-          self.encode.flatten.each do |datum|
-            # TWS wants to receive booleans as 1 or 0... rewrite as necessary.
-            datum = "1" if datum == true
-            datum = "0" if datum == false
-
-            #p datum.to_s + EOL
-            server[:socket].syswrite(datum.to_s + EOL)
+        def send_to server
+          self.encode(server).flatten.each do |datum|
+            server[:socket].write_data datum
           end
         end
 
         # At minimum, Outgoing message contains message_id and version.
         # Most messages also contain (ticker, request or order) :id.
         # Then, content of @data Hash is encoded per instructions in data_map.
-        def encode
+        def encode server
           [self.class.message_id,
            self.class.version,
            @data[:id] || @data[:ticker_id] || @data[:request_id]|| @data[:order_id] || [],
@@ -122,6 +117,11 @@ module IB
       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 }
+      # The API can now receive frozen market data from Trader Workstation. Frozen
+      # market data is the last data recorded in our system. Use this method with
+      # :market_data_type = 1 for real-time streaming, 2 for frozen market data
+      RequestMarketDataType = def_message 59, :market_data_type
 
       # @data = { :subscribe => boolean,
       #           :account_code => Advisor accounts only. Empty ('') for a standard account. }
@@ -292,50 +292,55 @@ module IB
                       :instrument,
                       :location_code,
                       :scan_code,
-                      [:above_price, EOL],
-                      [:below_price, EOL],
-                      [:above_volume, EOL],
-                      [:market_cap_above, EOL],
-                      [:market_cap_below, EOL],
+                      :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, EOL],
-                      [:coupon_rate_below, EOL],
+                      :coupon_rate_above,
+                      :coupon_rate_below,
                       :exclude_convertible,
-                      [:average_option_volume_above, EOL], # ?
+                      :average_option_volume_above, # ?
                       :scanner_setting_pairs,
                       :stock_type_filter)
 
       ### Even more complex Outgoing Message classes, overriding #encode method:
 
-      # Data format is { :id => order_id (int),
+
+      # Data format is { :id => int: order_id,
       #                  :contract => Contract,
       #                  :order => Order }
-      class PlaceOrder < AbstractMessage
-        @message_id = 3
-        @version = 31
+      PlaceOrder = def_message [3, 31] # 38 Need to set up Classes Hash properly
+
+      class PlaceOrder
+        def encode server
+
+          # Old server version supports no enhancements
+          @version = 31 if server[:server_version] <= 60
 
-        def encode
           [super,
-           @data[:order].serialize_with(@data[:contract])].flatten
+           @data[:order].serialize_with(server, @data[:contract])].flatten
         end
       end # PlaceOrder
 
-      module DataParser
+      # Messages that request bar data have special processing of @data
+      class BarRequestMessage < AbstractMessage
         # Preprocessor for some data fields
         def parse data
           data_type = DATA_TYPES[data[:what_to_show]] || data[:what_to_show]
           unless  DATA_TYPES.values.include?(data_type)
-            raise ArgumentError.new(":what_to_show must be one of #{DATA_TYPES.inspect}.")
+            error ":what_to_show must be one of #{DATA_TYPES.inspect}", :args
           end
 
           bar_size = BAR_SIZES[data[:bar_size]] || data[:bar_size]
           unless  BAR_SIZES.values.include?(bar_size)
-            raise ArgumentError.new(":bar_size must be one of #{BAR_SIZES.inspect}.")
+            error ":bar_size must be one of #{BAR_SIZES.inspect}", :args
           end
 
           contract = data[:contract].is_a?(Models::Contract) ?
@@ -347,7 +352,7 @@ module IB
 
       #  data = { :id => ticker_id (int),
       #           :contract => Contract ,
-      #           :bar_size => int/Symbol? Currently only 5 second bars (2?) are supported,
+      #           :bar_size => int/Symbol? Currently only 5 second bars are supported,
       #                        if any other value is used, an exception will be thrown.,
       #          :what_to_show => Symbol: Determines the nature of data being extracted.
       #                           Valid values:
@@ -361,13 +366,10 @@ module IB
       #                     "Regular Trading Hours" of the product in question is returned,
       #                     even if the time span requested falls partially or completely
       #                     outside of them.
-      class RequestRealTimeBars < AbstractMessage
-        @message_id = 50
-        @version = 1 # ?
-
-        include DataParser
+      RequestRealTimeBars = def_message 50, BarRequestMessage
 
-        def encode
+      class RequestRealTimeBars
+        def encode server
           data_type, bar_size, contract = parse @data
 
           [super,
@@ -449,13 +451,10 @@ module IB
       # For backfill on futures data, you may need to leave the Primary
       # Exchange field of the Contract structure blank; see
       # http://www.interactivebrokers.com/discus/messages/2/28477.html?1114646754
-      class RequestHistoricalData < AbstractMessage
-        @message_id = 20
-        @version = 4
+      RequestHistoricalData = def_message [20, 4], BarRequestMessage
 
-        include DataParser
-
-        def encode
+      class RequestHistoricalData
+        def encode server
           data_type, bar_size, contract = parse @data
 
           [super,
@@ -470,7 +469,6 @@ module IB
         end
       end # RequestHistoricalData
 
-
     end # module Outgoing
   end # module Messages
 end # module IB
@@ -512,3 +510,4 @@ __END__
     private static final int CANCEL_CALC_IMPLIED_VOLAT = 56;
     private static final int CANCEL_CALC_OPTION_PRICE = 57;
     private static final int REQ_GLOBAL_CANCEL = 58;
+     private static final int REQ_MARKET_DATA_TYPE = 59;