my-ib-api 0.0.1

data/lib/ib/messages/outgoing/abstract_message.rb

@@ -0,0 +1,73 @@
+require 'ib/messages/abstract_message'
+
+module IB
+  module Messages
+    module Outgoing
+
+      # Container for specific message classes, keyed by their message_ids
+      Classes = {}
+
+      class AbstractMessage < IB::Messages::AbstractMessage
+
+        def initialize data={}
+          @data = data
+          @created_at = Time.now
+        end
+
+        # This causes the message to send itself over the server socket in server[:socket].
+        # "server" is the @server instance variable from the IB object.
+        # You can also use this to e.g. get the server version number.
+        #
+        # Subclasses can either override this method for precise control over how
+        # stuff gets sent to the server, or else define a method encode() that returns
+        # 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 socket
+          self.preprocess.each {|data| socket.write_data data}
+        end
+
+        # Same message representation as logged by TWS into API messages log file
+        def to_s
+          self.preprocess.join('-')
+        end
+
+        # Pre-process encoded message Array before sending into socket, such as
+        # changing booleans into 0/1 and stuff
+        def preprocess
+          self.encode.flatten.map {|data| data == true ? 1 : data == false ? 0 : data }
+        end
+
+        # Encode message content into (possibly, nested) Array of values.
+        # At minimum, encoded 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.
+        # This method may be modified by message subclasses!
+        def encode
+          [self.class.message_id,
+           self.class.version,
+           @data[:id] || @data[:ticker_id] || @data[:request_id] ||
+           @data[:local_id] || @data[:order_id] || [],
+           self.class.data_map.map do |(field, default_method, args)|
+             case
+             when default_method.nil?
+               @data[field]
+
+             when default_method.is_a?(Symbol) # method name with args
+               @data[field].send default_method, *args
+
+             when default_method.respond_to?(:call) # callable with args
+               default_method.call @data[field], *args
+
+             else # default
+               @data[field].nil? ? default_method : @data[field] # may be false still
+             end
+           end
+           ]
+          # TWS wants to receive booleans as 1 or 0
+        end
+
+      end # AbstractMessage
+    end # module Outgoing
+  end # module Messages
+end # module IB

data/lib/ib/messages/outgoing/bar_requests.rb

@@ -0,0 +1,189 @@
+module IB
+  module Messages
+    module Outgoing
+
+      # Messages that request bar data have special processing of @data
+
+      class BarRequestMessage < AbstractMessage
+        # Preprocessor for some data fields
+        def parse data
+          type = data[:data_type] || data[:what_to_show]
+          data_type = DATA_TYPES.invert[type] || type
+          unless  DATA_TYPES.keys.include?(data_type)
+            error ":data_type must be one of #{DATA_TYPES.inspect}", :args
+          end
+
+          #size = data[:bar_size] || data[:size]
+          #bar_size = BAR_SIZES.invert[size] || size
+          # unless  BAR_SIZES.keys.include?(bar_size)
+            # error ":bar_size must be one of #{BAR_SIZES.inspect}", :args
+          # end
+
+          contract = data[:contract].is_a?(IB::Contract) ?
+              data[:contract] : IB::Contract.from_ib_ruby(data[:contract])
+
+          [data_type, nil, contract]
+        end
+      end
+
+      #  data = { :id => ticker_id (int),
+      #           :contract => Contract ,
+      #           :bar_size => int/Symbol? Currently only 5 second bars are supported,
+      #                        if any other value is used, an exception will be thrown.,
+      #           :data_type => Symbol: Determines the nature of data being extracted.
+      #                       :trades, :midpoint, :bid, :ask, :bid_ask,
+      #                       :historical_volatility, :option_implied_volatility,
+      #                       :option_volume, :option_open_interest
+      #                       - converts to "TRADES," "MIDPOINT," "BID," etc...
+      #          :use_rth => int: 0 - all data available during the time span requested
+      #                     is returned, even data bars covering time intervals where the
+      #                     market in question was illiquid. 1 - only data within the
+      #                     "Regular Trading Hours" of the product in question is returned,
+      #                     even if the time span requested falls partially or completely
+      #                     outside of them.
+      RequestRealTimeBars = def_message 50, BarRequestMessage
+
+      class RequestRealTimeBars
+        def parse data
+          data_type, bar_size, contract = super data
+
+          size = data[:bar_size] || data[:size]
+          bar_size = size.to_i
+          [data_type, bar_size, contract]
+        end
+
+        def encode
+          data_type, bar_size, contract = parse @data
+
+          [super,
+           contract.serialize_long,
+           bar_size,
+           data_type.to_s.upcase,
+           @data[:use_rth]]
+        end
+      end # RequestRealTimeBars
+
+      # data = { :id => int: Ticker id, needs to be different than the reqMktData ticker
+      #                 id. If you use the same ticker ID you used for the symbol when
+      #                 you did ReqMktData, nothing comes back for the historical data call
+      #          :contract => Contract: requested ticker description
+      #          :end_date_time => String: "yyyymmdd HH:mm:ss", with optional time zone
+      #                            allowed after a space: "20050701 18:26:44 GMT"
+      #          :duration => String, time span the request will cover, and is specified
+      #                  using the format: <integer> <unit>, eg: '1 D', valid units are:
+      #                        '1 S' (seconds, default if no unit is specified)
+      #                        '1 D' (days)
+      #                        '1 W' (weeks)
+      #                        '1 M' (months)
+      #                        '1 Y' (years, currently limited to one)
+      #          :bar_size => String: Specifies the size of the bars that will be returned
+      #                       (within IB/TWS limits). Valid values include:
+      #                             '1 sec'
+      #                             '5 secs'
+      #                             '15 secs'
+      #                             '30 secs'
+      #                             '1 min'
+      #                             '2 mins'
+      #                             '3 mins'
+      #                             '5 mins'
+      #                             '15 mins'
+      #                             '30 min'
+      #                             '1 hour'
+      #                             '1 day'
+      #          :what_to_show => Symbol: Determines the nature of data being extracted.
+      #                           Valid values:
+      #                             :trades, :midpoint, :bid, :ask, :bid_ask,
+      #                             :historical_volatility, :option_implied_volatility,
+      #                             :option_volume, :option_open_interest
+      #                              - converts to "TRADES," "MIDPOINT," "BID," etc...
+      #          :use_rth => int: 0 - all data available during the time span requested
+      #                     is returned, even data bars covering time intervals where the
+      #                     market in question was illiquid. 1 - only data within the
+      #                     "Regular Trading Hours" of the product in question is returned,
+      #                     even if the time span requested falls partially or completely
+      #                     outside of them.
+      #          :format_date => int: 1 - text format, like "20050307 11:32:16".
+      #                               2 - offset from 1970-01-01 in sec (UNIX epoch)
+      #         }
+      #
+      # NB: using the D :duration only returns bars in whole days, so requesting "1 D"
+      # for contract ending at 08:05 will only return 1 bar, for 08:00 on that day.
+      # But requesting "86400 S" gives 86400/barlengthsecs bars before the end Time.
+      #
+      # Note also that the :duration for any request must be such that the start Time is not
+      # more than one year before the CURRENT-Time-less-one-day (not 1 year before the end
+      # Time in the Request)
+      #
+      # Bar Size Max Duration
+      # -------- ------------
+      # 1 sec        2000 S
+      # 5 sec       10000 S
+      # 15 sec      30000 S
+      # 30 sec      86400 S
+      # 1 minute    86400 S, 6 D
+      # 2 minutes   86400 S, 6 D
+      # 5 minutes   86400 S, 6 D
+      # 15 minutes  86400 S, 6 D, 20 D, 2 W
+      # 30 minutes  86400 S, 34 D, 4 W, 1 M
+      # 1 hour      86400 S, 34 D, 4 w, 1 M
+      # 1 day       60 D, 12 M, 52 W, 1 Y
+      #
+      # NB: as of 4/07 there is no historical data available for forex spot.
+      #
+      # data[:contract] may either be a Contract object or a String. A String should be
+      # in serialize_ib_ruby format; that is, it should be a colon-delimited string in
+      # the format (e.g. for Globex British pound futures contract expiring in Sep-2008):
+      #
+      #    symbol:security_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+      #    GBP:FUT:200809:::62500:GLOBEX::USD:
+      #
+      # Fields not needed for a particular security should be left blank (e.g. strike
+      # and right are only relevant for options.)
+      #
+      # A Contract object will be automatically serialized into the required format.
+      #
+      # See also http://chuckcaplan.com/twsapi/index.php/void%20reqIntradayData%28%29
+      # for general information about how TWS handles historic data requests, whence
+      # the following has been adapted:
+      #
+      # The server providing historical prices appears to not always be
+      # available outside of market hours. If you call it outside of its
+      # supported time period, or if there is otherwise a problem with
+      # it, you will receive error #162 "Historical Market Data Service
+      # query failed.:HMDS query returned no data."
+      #
+      # 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
+      RequestHistoricalData = def_message [20, 4], BarRequestMessage
+
+      class RequestHistoricalData
+        def parse data
+          data_type, bar_size, contract = super data
+
+          size = data[:bar_size] || data[:size]
+          bar_size = BAR_SIZES.invert[size] || size
+          unless  BAR_SIZES.keys.include?(bar_size)
+            error ":bar_size must be one of #{BAR_SIZES.inspect}", :args
+          end
+          [data_type, bar_size, contract]
+        end
+
+        def encode
+          data_type, bar_size, contract = parse @data
+
+          [super,
+           contract.serialize_long(:include_expired),
+           @data[:end_date_time],
+           bar_size,
+           @data[:duration],
+           @data[:use_rth],
+           data_type.to_s.upcase,
+           @data[:format_date],
+           contract.serialize_legs]
+        end
+      end # RequestHistoricalData
+
+    end # module Outgoing
+  end # module Messages
+end # module IB

data/lib/ib/messages/outgoing/place_order.rb

@@ -0,0 +1,141 @@
+module IB
+  module Messages
+    module Outgoing
+
+      # Data format is { :id => int: local_id,
+      #                  :contract => Contract,
+      #                  :order => Order }
+      PlaceOrder = def_message [3, 38]
+
+      class PlaceOrder
+
+        def encode
+
+          order = @data[:order]
+          contract = @data[:contract]
+
+          [super,
+
+           contract.serialize_long(:con_id, :sec_id),
+
+           # main order fields
+           (order.side == :short ? 'SSHORT' : order.side == :short_exempt ? 'SSHORTX' : order.side.to_sup),
+           order.quantity,
+           order[:order_type], # Internal code, 'LMT' instead of :limit
+           order.limit_price,
+           order.aux_price,
+           order[:tif],
+           order.oca_group,
+           order.account,
+           order.open_close.to_sup[0..0],
+           order[:origin],
+           order.order_ref,
+           order.transmit,
+           order.parent_id,
+           order.block_order || false,
+           order.sweep_to_fill || false,
+           order.display_size,
+           order[:trigger_method],
+           order.outside_rth || false, # was: ignore_rth
+           order.hidden || false,
+           contract.serialize_legs(:extended),
+
+
+           if contract.bag?
+             [
+               ## Support for per-leg prices in Order
+               [contract.legs.size] + contract.legs.map { |_| nil },
+               ## Support for combo routing params in Order
+               order.combo_params.empty? ? 0 : [order.combo_params.size] + order.combo_params.to_a
+             ]
+           else
+             []
+           end,
+
+           '', # deprecated shares_allocation field
+           order.discretionary_amount,
+           order.good_after_time,
+           order.good_till_date,
+           order.fa_group,
+           order.fa_method,
+           order.fa_percentage,
+           order.fa_profile,
+           order[:short_sale_slot], # 0 only for retail, 1 or 2 for institution  (Institutional)
+           order.designated_location, # only populate when short_sale_slot == 2    (Institutional)
+           order.exempt_code,
+           order[:oca_type],
+           order[:rule_80a], #.to_sup[0..0],
+           order.settling_firm,
+           order.all_or_none || false,
+           order.min_quantity,
+           order.percent_offset,
+           order.etrade_only || false,
+           order.firm_quote_only || false,
+           order.nbbo_price_cap,
+           order[:auction_strategy],
+           order.starting_price,
+           order.stock_ref_price,
+           order.delta,
+           order.stock_range_lower,
+           order.stock_range_upper,
+           order.override_percentage_constraints || false,
+           order.volatility, #              Volatility orders
+           order[:volatility_type], #       Volatility orders
+
+           # Support for delta neutral orders with parameters
+           if order.delta_neutral_order_type && order.delta_neutral_order_type != :none
+             [order[:delta_neutral_order_type],
+              order.delta_neutral_aux_price,
+              order.delta_neutral_con_id,
+              order.delta_neutral_settling_firm,
+              order.delta_neutral_clearing_account,
+              order[:delta_neutral_clearing_intent]
+              ]
+           else
+             ['', '']
+           end,
+
+           order.continuous_update, #        Volatility orders
+           order[:reference_price_type], #   Volatility orders
+
+           order.trail_stop_price, #         TRAIL_STOP_LIMIT stop price
+           order.trailing_percent, #         Support for trailing percent
+
+           order.scale_init_level_size, #    Scale Orders
+           order.scale_subs_level_size, #    Scale Orders
+           order.scale_price_increment, #    Scale Orders
+
+           # Support for extended scale orders parameters
+           if order.scale_price_increment && order.scale_price_increment > 0
+             [order.scale_price_adjust_value,
+              order.scale_price_adjust_interval,
+              order.scale_profit_offset,
+              order.scale_auto_reset || false,
+              order.scale_init_position,
+              order.scale_init_fill_qty,
+              order.scale_random_percent || false
+              ]
+           else
+             []
+           end,
+
+           # Support for hedgeType
+           order.hedge_type, # MIN_SERVER_VER_HEDGE_ORDERS
+           order.hedge_param || [],
+
+           order.opt_out_smart_routing || false, # MIN_SERVER_VER_OPT_OUT_SMART_ROUTING
+
+           order.clearing_account,
+           order.clearing_intent,
+           order.not_held || false,
+           contract.serialize_under_comp,
+           order.serialize_algo(),
+           order.what_if]
+
+        end
+      end # PlaceOrder
+
+
+    end # module Outgoing
+  end # module Messages
+end # module IB

data/lib/ib/model.rb

@@ -0,0 +1,6 @@
+require 'ib/base_properties'
+require 'ib/base'
+
+module IB
+  Model =  IB::Base
+end

data/lib/ib/models.rb

@@ -0,0 +1,10 @@
+  require 'ib/model'
+
+  require 'models/ib/contract'
+  require 'models/ib/contract_detail'
+  require 'models/ib/underlying'
+  require 'models/ib/order_state'
+  require 'models/ib/order'
+  require 'models/ib/combo_leg'
+  require 'models/ib/execution'
+  require 'models/ib/bar'

data/lib/ib/requires.rb

@@ -0,0 +1,9 @@
+require 'ib/version'
+require 'ib/extensions'
+require 'ib/errors'
+require 'ib/constants'
+require 'ib/connection'
+require 'ib/flex'
+require 'ib/models'
+require 'ib/messages'
+require 'ib/symbols'

data/lib/ib/socket.rb

@@ -0,0 +1,81 @@
+require 'socket'
+
+module IB
+  class IBSocket < TCPSocket
+
+    # Sends null terminated data string into socket
+    def write_data data
+      self.syswrite(data.to_s + EOL)
+    end
+
+    def read_string
+      string = self.gets(EOL)
+
+      until string
+        # Silently ignores nils
+        string = self.gets(EOL)
+        sleep 0.1
+      end
+
+      string.chop
+    end
+
+    def read_int
+      self.read_string.to_i
+    end
+
+    def read_int_max
+      str = self.read_string
+      str.to_i unless str.nil? || str.empty?
+    end
+
+    def read_boolean
+      str = self.read_string
+      str.nil? ? false : str.to_i != 0
+    end
+
+    def read_decimal
+      # Floating-point numbers shouldn't be used to store money...
+      # ...but BigDecimals are too unwieldy to use in this case... maybe later
+      #  self.read_string.to_d
+      self.read_string.to_f
+    end
+
+    def read_decimal_max
+      str = self.read_string
+      # Floating-point numbers shouldn't be used to store money...
+      # ...but BigDecimals are too unwieldy to use in this case... maybe later
+      #  str.nil? || str.empty? ? nil : str.to_d
+      str.to_f unless str.nil? || str.empty? || str.to_f > 1.797 * 10.0 ** 306
+    end
+
+    # If received decimal is below limit ("not yet computed"), return nil
+    def read_decimal_limit limit = -1
+      value = self.read_decimal
+      # limit is the "not yet computed" indicator
+      value <= limit ? nil : value
+    end
+
+    alias read_decimal_limit_1 read_decimal_limit
+
+    def read_decimal_limit_2
+      read_decimal_limit -2
+    end
+
+    ### Complex operations
+
+    # Returns loaded Array or [] if count was 0
+    def read_array &block
+      count = read_int
+      count > 0 ? Array.new(count, &block) : []
+    end
+
+    # Returns loaded Hash
+    def read_hash
+      tags = read_array { |_| [read_string, read_string] }
+      tags.empty? ? Hash.new : Hash[*tags.flatten]
+    end
+
+  end # class IBSocket
+
+end # module IB