my-ib-api 0.0.1

data/lib/models/ib/contract.rb

@@ -0,0 +1,292 @@
+require 'models/ib/contract_detail'
+require 'models/ib/underlying'
+
+module IB
+  class Contract < IB::Model
+    include BaseProperties
+
+    # Fields are Strings unless noted otherwise
+    prop :con_id, # int: The unique contract identifier.
+      :currency, # Only needed if there is an ambiguity, e.g. when SMART exchange
+      #            and IBM is being requested (IBM can trade in GBP or USD).
+
+      :legs_description, # received in OpenOrder for all combos
+
+      :sec_type, # Security type. Valid values are: SECURITY_TYPES
+
+      :sec_id => :sup, # Unique identifier of the given secIdType.
+
+      :sec_id_type => :sup, # Security identifier, when querying contract details or
+      #               when placing orders. Supported identifiers are:
+      #               -  ISIN (Example: Apple: US0378331005)
+      #               -  CUSIP (Example: Apple: 037833100)
+      #               -  SEDOL (6-AN + check digit. Example: BAE: 0263494)
+      #               -  RIC (exchange-independent RIC Root and exchange-
+      #                  identifying suffix. Ex: AAPL.O for Apple on NASDAQ.)
+
+      :symbol => :s, # This is the symbol of the underlying asset.
+
+      :local_symbol => :s, # Local exchange symbol of the underlying asset
+
+      # Future/option contract multiplier (only needed when multiple possibilities exist)
+      :multiplier => {:set => :i},
+
+      :strike => :f, # double: The strike price.
+      :expiry => :s, # The expiration date. Use the format YYYYMM or YYYYMMDD
+      :exchange => :sup, # The order destination, such as Smart.
+      :primary_exchange => :sup, # Non-SMART exchange where the contract trades.
+      :include_expired => :bool, # When true, contract details requests and historical
+      #         data queries can be performed pertaining to expired contracts.
+      #         Note: Historical data queries on expired contracts are
+      #         limited to the last year of the contracts life, and are
+      #         only supported for expired futures contracts.
+      #         This field can NOT be set to true for orders.
+
+
+      # Specifies a Put or Call. Valid input values are: P, PUT, C, CALL
+    :right => {
+      :set => proc { |val|
+        self[:right] =
+        case val.to_s.upcase
+        when 'NONE', '', '0', '?'
+          ''
+        when 'PUT', 'P'
+          'P'
+        when 'CALL', 'C'
+          'C'
+        else
+          val
+        end
+      },
+      :validate => {:format => {:with => /\Aput$|^call$|^none\z/,
+                                :message => "should be put, call or none"}}
+    }
+
+    attr_accessor :description # NB: local to ib, not part of TWS.
+
+    ### Associations
+
+    has_many :orders # Placed for this Contract
+
+    has_many :bars # Possibly representing trading history for this Contract
+
+    has_one :contract_detail # Volatile info about this Contract
+
+    # For Contracts that are part of BAG
+    has_one :leg, :class_name => 'ComboLeg', :foreign_key => :leg_contract_id
+    has_one :combo, :class_name => 'Contract', :through => :leg
+
+    # for Combo/BAG Contracts that contain ComboLegs
+    has_many :combo_legs, :foreign_key => :combo_id
+    has_many :leg_contracts, :class_name => 'Contract', :through => :combo_legs
+    alias legs combo_legs
+    alias legs= combo_legs=
+
+      alias combo_legs_description legs_description
+    alias combo_legs_description= legs_description=
+
+      # for Delta-Neutral Combo Contracts
+      has_one :underlying
+    alias under_comp underlying
+    alias under_comp= underlying=
+
+
+      ### Extra validations
+      validates_inclusion_of :sec_type, :in => CODES[:sec_type].keys,
+      :message => "should be valid security type"
+
+    validates_format_of :expiry, :with => /\A\d{6}$|^\d{8}$|\A\z/,
+      :message => "should be YYYYMM or YYYYMMDD"
+
+    validates_format_of :primary_exchange, :without => /SMART/,
+      :message => "should not be SMART"
+
+    validates_format_of :sec_id_type, :with => /ISIN|SEDOL|CUSIP|RIC|\A\z/,
+      :message => "should be valid security identifier"
+
+    validates_numericality_of :multiplier, :strike, :allow_nil => true
+
+    def default_attributes
+      super.merge :con_id => 0,
+        :strike => 0.0,
+        :right => :none, # Not an option
+        :exchange => 'SMART',
+        :include_expired => false
+    end
+
+    # This returns an Array of data from the given contract.
+    # Different messages serialize contracts differently. Go figure.
+    # Note that it does NOT include the combo legs.
+    # serialize [:option, :con_id, :include_expired, :sec_id]
+    def serialize *fields
+      [(fields.include?(:con_id) ? [con_id] : []),
+       symbol,
+       self[:sec_type],
+       (fields.include?(:option) ?
+        [expiry,
+         strike,
+         self[:right],
+         multiplier] : []),
+       exchange,
+       (fields.include?(:primary_exchange) ? [primary_exchange] : []),
+       currency,
+       local_symbol,
+       (fields.include?(:sec_id) ? [sec_id_type, sec_id] : []),
+       (fields.include?(:include_expired) ? [include_expired] : []),
+       ].flatten
+    end
+
+    def serialize_long *fields
+      serialize :option, :primary_exchange, *fields
+    end
+
+    def serialize_short *fields
+      serialize :option, *fields
+    end
+
+    # Serialize under_comp parameters: EClientSocket.java, line 471
+    def serialize_under_comp *args
+      under_comp ? under_comp.serialize : [false]
+    end
+
+    # Defined in Contract, not BAG subclass to keep code DRY
+    def serialize_legs *fields
+      case
+      when !bag?
+        []
+      when legs.empty?
+        [0]
+      else
+        [legs.size, legs.map { |leg| leg.serialize *fields }].flatten
+      end
+    end
+
+    # This produces a string uniquely identifying this contract, in the format used
+    # for command line arguments in the IB-Ruby examples. The format is:
+    #
+    #    symbol:sec_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+    #
+    # Fields not needed for a particular security should be left blank
+    # (e.g. strike and right are only relevant for options.)
+    #
+    # For example, to query the British pound futures contract trading on Globex
+    # expiring in September, 2008, the string is:
+    #
+    #    GBP:FUT:200809:::62500:GLOBEX::USD:
+    def serialize_ib_ruby
+      serialize_long.join(":")
+    end
+
+    # Contract comparison
+    def == other
+      return true if super(other)
+
+      return false unless other.is_a?(self.class)
+
+      # Different sec_id_type
+      return false if sec_id_type && other.sec_id_type && sec_id_type != other.sec_id_type
+
+      # Different sec_id
+      return false if sec_id && other.sec_id && sec_id != other.sec_id
+
+      # Different symbols
+      return false if symbol && other.symbol && symbol != other.symbol
+
+      # Different currency
+      return false if currency && other.currency && currency != other.currency
+
+      # Same con_id for all Bags, but unknown for new Contracts...
+      # 0 or nil con_id  matches any
+      return false if con_id != 0 && other.con_id != 0 &&
+        con_id && other.con_id && con_id != other.con_id
+
+      # SMART or nil exchange matches any
+      return false if exchange != 'SMART' && other.exchange != 'SMART' &&
+        exchange && other.exchange && exchange != other.exchange
+
+      # Comparison for Bonds and Options
+      if bond? || option?
+        return false if right != other.right || strike != other.strike
+        return false if multiplier && other.multiplier &&
+          multiplier != other.multiplier
+        return false if expiry && expiry[0..5] != other.expiry[0..5]
+        return false unless expiry && (expiry[6..7] == other.expiry[6..7] ||
+                                       expiry[6..7].empty? || other.expiry[6..7].empty?)
+      end
+
+      # All else being equal...
+      sec_type == other.sec_type
+    end
+
+    def to_s
+      "<Contract: " + instance_variables.map do |key|
+        value = send(key[1..-1])
+        " #{key}=#{value}" unless value.nil? || value == '' || value == 0
+      end.compact.join(',') + " >"
+    end
+
+    def to_human
+      "<Contract: " +
+        [symbol,
+         sec_type,
+         (expiry == '' ? nil : expiry),
+         (right == :none ? nil : right),
+         (strike == 0 ? nil : strike),
+         exchange,
+         currency
+         ].compact.join(" ") + ">"
+    end
+
+    def to_short
+      "#{symbol}#{expiry}#{strike}#{right}#{exchange}#{currency}"
+    end
+
+    # Testing for type of contract:
+
+    def bag?
+      self[:sec_type] == 'BAG'
+    end
+
+    def bond?
+      self[:sec_type] == 'BOND'
+    end
+
+    def stock?
+      self[:sec_type] == 'STK'
+    end
+
+    def option?
+      self[:sec_type] == 'OPT'
+    end
+
+  end # class Contract
+
+
+  ### Now let's deal with Contract subclasses
+
+  require 'models/ib/option'
+  require 'models/ib/bag'
+
+  class Contract
+    # Contract subclasses representing specialized security types.
+    # Most security types do not have their own subclass, they use generic Contract class.
+    Subclasses = Hash.new(Contract)
+    Subclasses[:bag] = IB::Bag
+    Subclasses[:option] = IB::Option
+
+    # This builds an appropriate Contract subclass based on its type
+    def self.build opts = {}
+      subclass = VALUES[:sec_type][opts[:sec_type]] || opts[:sec_type].to_sym
+      Contract::Subclasses[subclass].new opts
+    end
+
+    # This returns a Contract initialized from the serialize_ib_ruby format string.
+    def self.from_ib_ruby string
+      keys = [:symbol, :sec_type, :expiry, :strike, :right, :multiplier,
+              :exchange, :primary_exchange, :currency, :local_symbol]
+      props = Hash[keys.zip(string.split(":"))]
+      props.delete_if { |k, v| v.nil? || v.empty? }
+      Contract.build props
+    end
+  end # class Contract
+end # module IB

data/lib/models/ib/contract_detail.rb

@@ -0,0 +1,89 @@
+module IB
+
+  # Additional Contract properties (volatile, therefore extracted)
+  class ContractDetail < IB::Model
+    include BaseProperties
+
+    # All fields Strings, unless specified otherwise:
+    prop :market_name, # The market name for this contract.
+      :trading_class, # The trading class name for this contract.
+      :min_tick, # double: The minimum price tick.
+      :price_magnifier, # int: Allows execution and strike prices to be reported
+      #                 consistently with market data, historical data and the
+      #                 order price: Z on LIFFE is reported in index points, not GBP.
+
+      :order_types, #       The list of valid order types for this contract.
+      :valid_exchanges, #   The list of exchanges this contract is traded on.
+      :under_con_id, # int: The underlying contract ID.
+      :long_name, #         Descriptive name of the asset.
+      :contract_month, #    The contract month of the underlying futures contract.
+
+      # For Bonds only
+      :valid_next_option_date,
+      :valid_next_option_type,
+      :valid_next_option_partial,
+
+      # The industry classification of the underlying/product:
+      :industry, #    Wide industry. For example, Financial.
+      :category, #    Industry category. For example, InvestmentSvc.
+      :subcategory, # Subcategory. For example, Brokerage.
+      [:time_zone, :time_zone_id], # Time zone for the trading hours (e.g. EST)
+      :trading_hours, # The trading hours of the product. For example:
+      #                 20090507:0700-1830,1830-2330;20090508:CLOSED.
+      :liquid_hours, #  The liquid trading hours of the product. For example,
+      #                 20090507:0930-1600;20090508:CLOSED.
+
+      # To support products in Australia which trade in non-currency units, the following
+      # attributes have been added to Execution and Contract Details objects:
+      :ev_rule, # evRule - String contains the Economic Value Rule name and optional argument,
+      #          separated by a colon. Examle: aussieBond:YearsToExpiration=3.
+      #          When the optional argument not present, the value will be followed by a colon.
+      [:ev_multiplier, :ev_multipler], # evMultiplier - double, tells you approximately
+      #          how much the market value of a contract would change if the price were
+      #          to change by 1. It cannot be used to get market value by multiplying
+      #          the price by the approximate multiplier.
+
+      :sec_id_list, # Hash with multiple Security ids
+
+      # BOND values:
+      :cusip, # The nine-character bond CUSIP or the 12-character SEDOL.
+      :ratings, # Credit rating of the issuer. Higher rating is less risky investment.
+      #           Bond ratings are from Moody's and S&P respectively.
+      :desc_append, # Additional descriptive information about the bond.
+      :bond_type, #   The type of bond, such as "CORP."
+      :coupon_type, # The type of bond coupon.
+      :coupon, # double: The interest rate used to calculate the amount you
+      #          will receive in interest payments over the year. default 0
+      :maturity, # The date on which the issuer must repay bond face value
+      :issue_date, # The date the bond was issued.
+      :next_option_date, # only if bond has embedded options.
+      :next_option_type, # only if bond has embedded options.
+      :notes, # Additional notes, if populated for the bond in IB's database
+      :callable => :bool, # Can be called by the issuer under certain conditions.
+      :puttable => :bool, # Can be sold back to the issuer under certain conditions
+      :convertible => :bool, # Can be converted to stock under certain conditions.
+      :next_option_partial => :bool # # only if bond has embedded options.
+
+      # Extra validations
+      validates_format_of :time_zone, :with => /\A\w{3}\z/, :message => 'should be XXX'
+
+    serialize :sec_id_list, HashWithIndifferentAccess
+
+    belongs_to :contract
+    alias summary contract
+    alias summary= contract=
+
+    def default_attributes
+      super.merge :coupon => 0.0,
+        :under_con_id => 0,
+        :min_tick => 0,
+        :ev_multipler => 0,
+        :sec_id_list => HashWithIndifferentAccess.new,
+        :callable => false,
+        :puttable => false,
+        :convertible => false,
+        :next_option_partial => false
+    end
+
+  end # class ContractDetail
+end # module IB

data/lib/models/ib/execution.rb

@@ -0,0 +1,65 @@
+module IB
+
+  # This is IB Order execution report.
+  class Execution < IB::Model
+    include BaseProperties
+
+    belongs_to :order
+
+    prop :local_id, #   int: order id. TWS orders have a fixed order id of 0.
+      :client_id, #     int: client id. TWS orders have a fixed client id of 0.
+      :perm_id, #       int: TWS id used to identify orders over TWS sessions
+      :exec_id, #       String: Unique order execution id over TWS sessions.
+      :time, #         # TODO: convert into Time object?
+      #                 String: The order execution time.
+      :exchange, #      String: Exchange that executed the order.
+      :order_ref, #     String: Same order_ref as in corresponding Order
+      :price, #         double: The order execution price.
+      :average_price, # double: Used in regular trades, combo trades and legs of the combo.
+      :ev_rule, #       String: Australian products only
+      :ev_multiplier, # double: Australian products only
+
+      [:quantity, :shares], #       int: The number of shares filled.
+      :cumulative_quantity, # int: Used in regular trades, combo trades and legs of combo
+      :liquidation => :bool, # This position is liquidated last should the need arise.
+      [:account_name, :account_number] => :s, # The customer account number.
+      [:side, :action] => PROPS[:side] # Was the transaction a buy or a sale: BOT|SLD
+
+    # Extra validations
+    validates_numericality_of :quantity, :cumulative_quantity, :price, :average_price
+    validates_numericality_of :local_id, :client_id, :perm_id, :only_integer => true
+
+    def default_attributes
+      super.merge :local_id => 0,
+        :client_id => 0,
+        :quantity => 0,
+        :price => 0,
+        :perm_id => 0,
+        :liquidation => false
+    end
+
+    # Comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        perm_id == other.perm_id &&
+        local_id == other.local_id && # ((p __LINE__)||true) &&
+        client_id == other.client_id &&
+        exec_id == other.exec_id &&
+        time == other.time &&
+        exchange == other.exchange &&
+        order_ref == other.order_ref &&
+        side == other.side
+      # TODO: || compare all attributes!
+    end
+
+    def to_human
+      "<Execution: #{time} #{side} #{quantity} at #{price} on #{exchange}, " +
+        "cumulative #{cumulative_quantity} at #{average_price}, " +
+        "ids #{local_id}/#{perm_id}/#{exec_id}>"
+    end
+
+    alias to_s to_human
+
+  end # Execution
+end # module IB

data/lib/models/ib/option.rb

@@ -0,0 +1,60 @@
+require 'models/ib/contract'
+
+module IB
+  class Option < Contract
+
+    validates_numericality_of :strike, :greater_than => 0
+    validates_format_of :sec_type, :with => /\Aoption\z/,
+      :message => "should be an option"
+    validates_format_of :local_symbol, :with => /\A\w+\s*\d{6}[pcPC]\d{8}$|\A\z/,
+      :message => "invalid OSI code"
+    validates_format_of :right, :with => /\Aput$|^call\z/,
+      :message => "should be put or call"
+
+    # For Options, this is contract's OSI (Option Symbology Initiative) name/code
+    alias osi local_symbol
+
+    def osi= value
+      # Normalize to 21 char
+      self.local_symbol = value.sub(/ /, ' '*(22-value.size))
+    end
+
+    # Make valid IB Contract definition from OSI (Option Symbology Initiative) code.
+    # NB: Simply making a new Contract with *local_symbol* (osi) property set to a
+    # valid OSI code works just as well, just do NOT set *expiry*, *right* or
+    # *strike* properties in this case.
+    # This class method provided as a backup and shows how to analyse OSI codes.
+    def self.from_osi osi
+
+      # Parse contract's OSI (OCC Option Symbology Initiative) code
+      args = osi.match(/(\w+)\s?(\d\d)(\d\d)(\d\d)([pcPC])(\d+)/).to_a.drop(1)
+      symbol = args.shift
+      year = 2000 + args.shift.to_i
+      month = args.shift.to_i
+      day = args.shift.to_i
+      right = args.shift.upcase
+      strike = args.shift.to_i/1000.0
+
+      # Set correct expiry date - IB expiry date differs from OSI if expiry date
+      # falls on Saturday (see https://github.com/arvicco/option_mower/issues/4)
+      expiry_date = Time.utc(year, month, day)
+      expiry_date = Time.utc(year, month, day-1) if expiry_date.wday == 6
+
+      new :symbol => symbol,
+        :exchange => "SMART",
+        :expiry => expiry_date.to_ib[2..7], # YYMMDD
+        :right => right,
+        :strike => strike
+    end
+
+    def default_attributes
+      super.merge :sec_type => :option
+      #self[:description] ||= osi ? osi : "#{symbol} #{strike} #{right} #{expiry}"
+    end
+
+    def to_human
+      "<Option: " + [symbol, expiry, right, strike, exchange, currency].join(" ") + ">"
+    end
+
+  end # class Option
+end # module IB