ib-api 10.33.1

data/lib/support/array_function.rb

@@ -0,0 +1,28 @@
+module Support
+  module ArrayFunction
+    def save_insert item, key, overwrite = true
+      member = find { |entry| entry[ key ] == item[ key]  }
+      if member
+        self[ index( member ) ] = item if overwrite
+      else
+        self << item
+      end
+      self  # always returns the array
+    end
+
+    # performs [ [ array ] & [ array ] & [..] ].first
+    def intercept
+      a = self.dup
+      s = a.pop
+      while a.present?
+        s = s & a.pop
+      end
+      s.first unless s.nil?  # return_value (or nil)
+    end
+  end  # module
+end  # module
+
+class Array
+  include Support::ArrayFunction
+end
+

data/lib/support/logging.rb

@@ -0,0 +1,45 @@
+#module Kernel
+#  private
+#  def this_method_name
+#    caller[0] =~ /`([^']*)'/  and $1
+#  end
+#   see also __method__  and __callee__
+#end
+
+
+
+module Support
+  module Logging
+    def self.included(base)
+      base.extend ClassMethods
+      base.send :define_method, :logger do
+        base.logger
+      end
+    end
+
+    module ClassMethods
+      def logger
+        @logger
+      end
+
+      def logger=(logger)
+        @logger = logger
+      end
+
+      def configure_logger(log=nil)
+        if log
+          @logger = log
+        else
+          @logger = ::Logger.new(STDOUT)
+          @logger.level = ::Logger::INFO
+          @logger.formatter = proc do |severity, datetime, progname, msg|
+          # "#{datetime.strftime("%d.%m.(%X)")}#{"%5s" % severity}->#{msg}\n"
+            "#{"%1s" % severity[0]}: #{msg}\n"
+          end
+            @logger.debug "------------------------------ start logging ----------------------------"
+        end # branch
+      end # def
+    end # module ClassMethods
+  end # module Logging
+end # module Support
+

data/models/ib/account.rb

@@ -0,0 +1,72 @@
+module IB
+  class Account < IB::Base
+    include BaseProperties
+    #  attr_accessible :alias, :account, :connected
+
+    prop :account,  # String 
+      :alias,     # 
+      :type,
+      :last_updated,
+      :connected => :bool
+
+
+
+    validates_format_of :account, :with =>  /\A[D]?[UF]{1}\d{5,8}\z/ , :message => 'should be (X)X00000'
+
+    # in tableless mode the scope is ignored
+
+    has_many :account_values
+    has_many :portfolio_values
+    has_many :contracts
+    has_many :orders
+    has_many :focuses
+
+    def default_attributes
+      super.merge account: 'X000000'
+      super.merge alias: ''
+      super.merge type: 'Account'
+      super.merge connected: false
+    end
+
+    def logger  #nodoc#
+      Connection.logger
+    end
+
+    def print_type #nodoc#
+      (test_environment? ? "demo_"  : "") + ( user? ? "user" : "advisor" )
+    end
+
+    def advisor?
+      !!(type =~ /Advisor/ || account =~ /\A[D]?[F]{1}/)
+    end
+
+    def user?
+      !!(type =~ /User/ || account =~ /\A[D]?[U]{1}/)
+    end
+
+    def test_environment?
+      !!(account =~ /^[D]{1}/)
+    end
+
+    def == other
+      super(other) ||
+        other.is_a?(self.class) && account == other.account
+    end 
+
+    def to_human
+      a = if self.alias.present?  && self.alias != account
+            " alias: "+ self.alias
+          else
+            ""
+          end
+        "<#{print_type} #{account}#{a}>"
+    end
+
+    def name  #nodoc#
+      self.alias.present? ? self.alias : account
+    end
+
+#   alias :id :account
+end # class
+
+end # module

data/models/ib/account_value.rb

@@ -0,0 +1,33 @@
+module IB
+  # Instantiate with a Hash of attributes, to be auto-set via initialize in Model.
+  class AccountValue < IB::Base
+    include BaseProperties
+
+    belongs_to :account 
+
+    prop  :key,
+    :value,
+    :currency
+
+
+    #  comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        key == other.key &&
+        currency == other.currency &&
+        value == other.value 
+    end
+    def default_attributes
+      super.merge key: 'AccountValue',
+  value: 0,
+  currency: 'USD'
+    end
+
+    def to_human
+       "<#{key}=#{value} #{currency}>"
+    end
+
+    alias to_s to_human
+  end # class 
+end # module IB

data/models/ib/bag.rb

@@ -0,0 +1,55 @@
+module IB
+
+  # "BAG" is not really a contract, but a combination (combo) of securities.
+  # AKA basket or bag of securities. Individual securities in combo are represented
+  # by ComboLeg objects.
+  class Bag < Contract
+    # General Notes:
+    # 1. :exchange for the leg definition must match that of the combination order.
+    # The exception is for a STK legs, which must specify the SMART exchange.
+    # 2. :symbol => "USD" For combo Contract, this is an arbitrary value (like "USD")
+
+   prop :combo_params # bags carry "non_guarantieed: true/false" in combo_params
+
+
+    validates_format_of :sec_type, :with => /\Abag\z/, :message => "should be a bag"
+    validates_format_of :right, :with => /\Anone\z/, :message => "should be none"
+    validates_format_of :expiry, :with => /\A\z/, :message => "should be blank"
+
+    def default_attributes
+      super.merge :sec_type => :bag #,:legs => Array.new,
+    end
+
+#    def description
+#      self[:description] || to_human
+#    end
+
+    def to_human
+      "<Bag: #{[symbol, exchange, currency].join(' ')} legs: #{legs_description} >"
+    end
+
+    def con_id= arg
+      # dont' update con_id
+    end
+
+    ### Leg-related methods
+
+    # IB-equivalent leg description.
+    def legs_description
+      self[:legs_description] || combo_legs.map { |the_leg| "#{the_leg.con_id}|#{the_leg.weight}" }.join(',')
+    end
+
+    # Check if two Contracts have same legs (maybe in different order)
+    def same_legs? other
+      combo_legs == other.combo_legs ||
+        legs_description.split(',').sort == other.legs_description.split(',').sort
+    end
+
+
+    # Contract comparison
+    def == other
+      super && same_legs?(other)
+    end
+
+  end # class Bag
+end # IB

data/models/ib/bar.rb

@@ -0,0 +1,31 @@
+module IB
+  # This is a single data point delivered by HistoricData or RealTimeBar messages.
+  # Instantiate with a Hash of attributes, to be auto-set via initialize in Model.
+  class Bar < IB::Base
+    include BaseProperties
+
+    has_one :contract # The bar represents timeseries info for this Contract
+
+    prop :open, #   The bar opening price.
+      :high, #   The high price during the time covered by the bar.
+      :low, #    The low price during the time covered by the bar.
+      :close, #  The bar closing price.
+      :volume, # Volume
+      :wap, #    Weighted average price during the time covered by the bar.
+      :trades, # int: When TRADES data history is returned, represents number
+      #           of trades that occurred during the time period the bar covers
+      :time #DateTime
+      #        The date-time stamp of the start of the bar. The format is
+      #        determined by the reqHistoricalData() formatDate parameter.
+#      :has_gaps => :bool # Whether or not there are gaps in the data.  ## omitted since ServerVersion 124
+
+      validates_numericality_of :open, :high, :low, :close, :volume
+
+   def to_human
+     "<Bar: #{time.strftime("(%d.%m.%y)%X")} wap #{wap.round(3)} OHLC #{open} #{high} #{low} #{close} " +
+        (trades ? "trades #{trades}" : "") + " vol #{volume}>"
+    end
+
+    alias to_s to_human
+  end # class Bar
+end # module IB

data/models/ib/combo_leg.rb

@@ -0,0 +1,127 @@
+module IB
+
+  # ComboLeg is essentially a join Model between Combo (BAG) Contract and
+  # individual Contracts (securities) that this BAG contains.
+  class ComboLeg < IB::Base
+    include BaseProperties
+
+    # BAG Combo Contract that contains this Leg
+#    belongs_to :combo, :class_name => 'Contract'
+    # Contract that constitutes this Leg
+#    belongs_to :leg_contract, :class_name => 'Contract', :foreign_key => :leg_contract_id
+
+    # General Notes:
+    # 1. The exchange for the leg definition must match that of the combination order.
+    # The exception is for a STK leg definition, which must specify the SMART exchange.
+
+    prop :con_id, # int: The unique contract identifier specifying the security.
+      :ratio, # int: Select the relative number of contracts for the leg you
+      #              are constructing. To help determine the ratio for a
+      #              specific combination order, refer to the Interactive
+      #              Analytics section of the User's Guide.
+      :exchange, # String: exchange to which the complete combo order will be routed.
+      #
+      # For institutional customers only! For stock legs when doing short sale
+      :short_sale_slot, # int:  0 - retail(default), 
+                        #       1 = clearing broker, 2 = third party
+      :designated_location, # String: Only for shortSaleSlot == 2.
+      #                    Otherwise leave blank or orders will be rejected.
+      :exempt_code, # int: (-1) 
+      [:side, :action] => PROPS[:side], # String: Action/side: BUY/SELL/SSHORT/SSHORTX
+      :open_close => PROPS[:open_close]
+    # int: Whether the order is an open or close order. Values:
+    # SAME = 0 Same as the parent security. The only option for retail customers.
+    # OPEN = 1 Open. This value is only valid for institutional customers.
+    # CLOSE = 2 Close. This value is only valid for institutional customers.
+    # UNKNOWN = 3
+     :price  # support for pet leg prices
+
+    # Extra validations
+    validates_numericality_of :ratio, :con_id
+    validates_format_of :designated_location, :with => /\A\z/,
+      :message => "should be blank or orders will be rejected"
+
+    def default_attributes
+      super.merge :con_id => 0,
+        :ratio => 1,
+        :side => :buy,
+        :open_close => :same, # The only option for retail customers.
+        :short_sale_slot => :default,
+        :designated_location => '',
+        :exchange => 'SMART', # Unless SMART, Order modification fails
+        :exempt_code => -1
+    end
+
+    #  Leg's weight is a combination of action and ratio
+    def weight
+      side == :buy ? ratio : -ratio
+    end
+
+    def weight= value
+      value = value.to_i
+      if value > 0
+        self.side = :buy
+        self.ratio = value
+      else
+        self.side = :sell
+        self.ratio = -value
+      end
+    end
+
+    # Some messages include open_close, some don't. wtf.
+    def serialize *fields
+      [con_id,
+       ratio,
+       side.to_sup,
+       exchange,
+       (fields.include?(:extended) ?
+        [self[:open_close],
+         self[:short_sale_slot],
+         designated_location,
+         exempt_code] :
+        [])
+       ].flatten
+    end
+
+    
+     # fields are generated by serialize(:extended)
+    # i.e.
+# z=  Strangle.build from: Symbols::Index.stoxx, p: 3700, c: 4000, expiry: 202106
+# zc= z.combo_legs.serialize :extended
+# => [[321584786, 1, "BUY", "DTB", 0, 0, "", -1], [321584637, 1, "BUY", "DTB", 0, 0, "", -1]] 
+# nz = zc.map{|o| ComboLeg.build *o }
+# zc.map{|o| ComboLeg.build o }     =>    #  is equivalent
+# => [#<IB::ComboLeg:0x0000000001c36bc0 @attributes={:con_id=>321584786, :ratio=>1, :side=>"B", :exchange=>"DTB", ... 
+# nz.first == z.combo_legs.first    => true 
+# 
+    def self.build *fields
+      self.new Hash[[:con_id,
+                 :ratio,
+                 :side,    #  reverse to_sup?
+                 :exchange,
+                 :open_close,
+                 :short_sale_slot,
+                 :designated_location,
+                 :exempt_code].zip fields]
+    end
+
+    def to_human
+      "<ComboLeg: #{side} #{ratio} con_id #{con_id} at #{exchange}>"
+    end
+
+    # Order comparison
+    def == other
+      super(other) ||
+        other.is_a?(self.class) &&
+        con_id == other.con_id &&
+        ratio == other.ratio &&
+        open_close == other.open_close && 
+        short_sale_slot == other.short_sale_slot &&
+        exempt_code == other.exempt_code &&
+        side == other.side &&
+        exchange == other.exchange &&
+        designated_location == other.designated_location
+    end
+
+  end # ComboLeg
+end # module IB