ib-api 10.33.1

data/plugins/ib/symbols/index.rb

@@ -0,0 +1,43 @@
+# Frequently used stock contracts definitions
+module IB
+  module Symbols
+    module Index
+      extend Symbols
+
+      def self.contracts
+     @contracts.presence ||  super.merge(
+         :dax =>     IB::Index.new( :symbol => "DAX", :currency => "EUR", exchange: 'EUREX',
+                                    :description => "DAX Performance Index."),
+         :asx =>     IB::Index.new( :symbol  => 'AP', :currency => 'AUD', exchange: 'ASX',
+                                    :description => "ASX 200 Index (Base for IndexOptions)" ),
+         :hsi =>     IB::Index.new( :symbol  => 'HSI', :currency => 'HKD', exchange: 'HKFE',
+                                    :description => "Hang Seng Index" ),
+         :minihsi => IB::Index.new( :symbol  => 'MHI', :currency => 'HKD', exchange: 'HKFE',
+                                    :description => "Mini Hang Seng Index" ),
+         :stoxx =>   IB::Index.new( :symbol => "ESTX50", :currency => "EUR", exchange: 'EUREX',
+                                    :description => "Dow Jones Euro STOXX50"),
+         :spx =>     IB::Index.new( :symbol => "SPX", :currency => "USD", exchange: 'CBOE',
+                                    :description => "S&P 500 Stock Index"),
+         :vhsi =>    IB::Index.new( symbol: 'VHSI', exchange: 'HKFE',
+                                    :description => "Hang Seng Volatility Index"),
+         :vasx  =>   IB::Index.new( symbol: 'XVI',   exchange: 'ASX',
+                                    :description => "ASX 200 Volatility Index") ,
+         :vstoxx =>  IB::Index.new( :symbol => "V2TX", :currency => "EUR", exchange: 'EUREX',
+                                    :description => "VSTOXX Volatility Index"),
+         :vdax =>    IB::Index.new( :symbol => "VDAX", exchange: 'EUREX',
+                                    :description => "German VDAX Volatility Index"),
+         :vix =>     IB::Index.new( :symbol => "VIX", exchange: 'CBOE',
+                                    :description => "CBOE Volatility Index"),
+        :volume =>   IB::Index.new( symbol: 'VOL-NYSE', exchange: 'NYSE',
+                                    description: "NYSE Volume Index" ),
+        :trin =>     IB::Index.new( symbol: 'TRIN-NYSE', exchange: 'NYSE',
+                                    description: "NYSE TRIN (or arms) Index"),
+        :tick =>     IB::Index.new( symbol: 'TICK-NYSE', exchange: 'NYSE',
+                                    description: "NYSE TICK Index"),
+        :a_d =>      IB::Index.new( symbol: 'AD-NYSE', exchange: 'NYSE',
+                                    description: "NYSE Advance Decline Index")       )
+      end
+
+    end
+  end
+end

data/plugins/ib/symbols/options.rb

@@ -0,0 +1,99 @@
+# Option contracts definitions.
+# TODO: add next_expiry and other convenience from Futures module.
+# Notice:  OSI-Notation is broken
+module IB
+  module Symbols
+    module Options
+      extend Symbols
+
+      ## usage:  IB::Symbols::Options.stoxx.merge( strike: 5000, expiry: 202404 )
+      ##         IB::Symbols::Options.stoxx.merge( strike: 5000 ).next_expiry =>  fetch the next regulary
+      ##                                                                          monthly option (3.rd friday)
+      def self.contracts
+        @contracts ||= {
+          stoxx:  IB::Option.new(symbol: :ESTX50,
+                                 expiry: IB::Option.next_expiry ,
+                                 right: :put,
+                                 trading_class: 'OESX',
+                                 currency: 'EUR',
+                                 exchange: 'EUREX',
+                                 description: "Monthly settled ESTX50  Options"),
+          spx:  IB::Option.new(  symbol: :SPX,
+                                 expiry: IB::Option.next_expiry ,
+                                 right: :put,
+                                 trading_class: 'SPX',
+                                 currency: 'USD',
+                                 exchange: 'SMART',
+                                 description: "Monthly settled SPX options"),
+         spxw:  IB::Option.new(  symbol: :SPX,
+                                 expiry: IB::Option.next_expiry ,
+                                 right: :put,
+                                 trading_class: 'SPXW',
+                                 currency: 'USD', exchange: 'SMART',
+                                 description: "Daily settled SPX options"),
+         xsp:   IB::Option.new(  symbol: 'XSP',
+                                 expiry: IB::Option.next_expiry ,
+                                 right: :put,
+                                 trading_class: 'XSP',
+                                 currency: 'USD',
+                                 exchange: 'SMART',
+                                 description: "Daily settled Mini-SPX options"),
+        :spy => IB::Option.new( :symbol   => :SPY,
+                                :expiry   => IB::Option.next_expiry,
+                                :right    => :put,
+                                :currency => "USD",
+                                :exchange => 'SMART',
+                                :description => "SPY Put next expiration"),
+        :rut => IB::Option.new( :symbol   => :RUT,
+                                :expiry   => IB::Option.next_expiry,
+                                :right    => :put,
+                                :currency => "USD",
+                                :exchange => 'SMART',
+                                :trading_class => 'RUT',
+                                 description: "Monthly settled RUT options"),
+        :rutw => IB::Option.new( :symbol   => :RUT,
+                                :expiry   => IB::Option.next_expiry,
+                                :right    => :put,
+                                :currency => "USD",
+                                :exchange => 'SMART',
+                                 description: "Weekly settled RUT options"),
+        :russell => IB::Option.new( :symbol   => :RUT,                             # :russell  == :rut !
+                                :expiry   => IB::Option.next_expiry,
+                                :right    => :put,
+                                :currency => "USD",
+                                :exchange => 'SMART',
+                                 description: "Monthly settled RUT options"),
+        :mini_russell => IB::Option.new( :symbol   => :MRUT,
+                                :expiry   => IB::Option.next_expiry,
+                                :right    => :put,
+                                :currency => "USD",
+                                :exchange => 'SMART',
+                                :description => "Weekly settled Mini-Russell2000 options"),
+       :aapl => IB::Option.new( :symbol => "AAPL",
+                                :expiry => IB::Option.next_expiry,
+                                :right => "C",
+                                :strike => 150,
+                                :exchange => 'SMART',
+                                :currency => 'USD',
+                                :description => "Apple Call 130"),
+
+      :ibm => IB::Option.new( symbol: 'IBM',
+                            exchange: 'SMART',
+                               right: :put,
+                              expiry: IB::Option.next_expiry ,
+                         description: 'IBM-Option'),
+      :ibm_lazy_expiry => IB::Option.new( symbol: 'IBM',
+                                           right: :put,
+                                          strike: 180,
+                                        exchange: 'SMART',
+                                     description: 'IBM-Option Chain with strike 180'),
+      :ibm_lazy_strike => IB::Option.new( symbol: 'IBM',
+                                           right: :put,
+                                        exchange: 'SMART',
+                                          expiry: IB::Option.next_expiry,
+                                     description: 'IBM-Option Chain ( monthly expiry)')
+        }
+      end
+    end
+  end
+end

data/plugins/ib/symbols/stocks.rb

@@ -0,0 +1,44 @@
+# Frequently used stock contracts definitions
+# TODO: auto-request :ContractDetails from IB if unknown symbol is requested?
+module IB
+  module Symbols
+    module Stocks
+      extend Symbols
+
+      def self.contracts
+ @contracts.presence || super.merge(
+   :ib_smart =>   IB::Stock.new( :symbol => 'IBKR',
+                                 :description  => 'Interactive Brokers Stock with smart exchange setting'),
+   :ib =>         IB::Stock.new( :symbol=>  'IBKR', exchange: 'ISLAND',
+                                 :description  => 'Interactive Brokers Stock'),
+   :aapl =>       IB::Stock.new( :symbol => "AAPL",
+                                 :currency => "USD",
+                                 :description => "Apple Inc."),
+
+   :msft_conid => IB::Stock.new(      con_id: 272093,
+                                    currency: :usd ,
+                                 description: 'Microsoft selected by its con-id'),
+   :msft =>       IB::Stock.new(      symbol: 'MSFT',
+                                 description: 'Microsoft selected by its symbol'),
+   :msft_island =>IB::Stock.new(      symbol: 'MSFT', primary_exchange: 'ISLAND',
+                                 description: 'Microsoft, primary trading @ ISLAND'),
+   :vxx =>        IB::Stock.new( :symbol => "VXX",
+                                 :exchange => "ARCA",
+                                 :description => "iPath S&P500 VIX short term Futures ETN"),
+   :wfc =>        IB::Stock.new( :symbol => "WFC",
+                                 :exchange => "NYSE",
+                                 :currency => "USD",
+                                 :description => "Wells Fargo"),
+   :sie =>        IB::Stock.new(      symbol: 'SIE',
+                                    currency: 'EUR',
+                                 description: 'Siemens AG'),
+  :wrong =>       IB::Stock.new( :symbol => "QEEUUE",
+                                 :exchange => "NYSE",
+                                 :currency => "USD",
+                                 :description => "Non-existent stock")
+                            )
+      end
+
+    end
+  end
+end

data/plugins/ib/symbols/version.rb

@@ -0,0 +1,5 @@
+module IB
+  module Symbols
+    VERSION = "2.0"
+  end
+end

data/plugins/ib/symbols.rb

@@ -0,0 +1,118 @@
+=begin
+
+Plugin that provides helper methods for predefined Contracts
+
+
+Public API
+==========
+
+Extends IB::Contract
+
+=end
+
+# These modules are used to facilitate referencing of most popular IB Contracts.
+# Like pages in the TWS-GUI, they can be utilised to organise trading and research.
+#
+# Symbol Allocations are organized as modules. They represent the contents of yaml files in
+#
+#   /lib/symbols/
+#
+# Any collection is represented as simple Hash, with  __key__ as qualifier and an __IB::Contract__ as value.
+# The Value is either a fully prequalified Contract  (Stock, Option, Future, Forex, CFD, BAG) or
+# a lazy qualified Contract acting as base für further calucaltions and requests.
+#
+#   IB::Symbols.allocate_collection :Name
+#
+# creates the Module and file. If a previously created file is found, its contents are read and
+# the vcollection ist reestablished.
+#
+#   IB::Symbols::Name.add_contract :wfc, IB::Stock.new( symbol: 'WFC' )
+#
+# adds the contract and stores it in the yaml file
+#
+#   IB::Symbols::Name.wfc   # or  IB::Symbols::Name[:wfc]
+#
+# retrieves the contract
+#
+#   IB::Symbols::Name.all
+#
+# returns an Array of stored contracts
+#
+#   IB::Symbols::Name.remove_contract :wfc
+#
+# deletes the contract from the list (and the file)
+#
+# To finish the cycle
+#
+#   IB::Symbols::Name.purge_collection
+#
+# deletes the file and erases the collection in memory.
+#
+# Additional methods can be introduced
+#   * for individual contracts on the module-level or
+#   * to organize the list as methods of Array in  Module IB::SymbolExtention
+#
+#
+# Contracts can be hardcoded in the required standard-collections as well.
+# Note that the :description field is local to ib-ruby, and is NOT part of the standard TWS API.
+# It is never transmitted to IB. It's purely used clientside, and you can store any arbitrary
+# string that you may find useful there.
+
+module IB
+  module Symbols
+    class Error < StandardError; end
+
+
+
+    def hardcoded?
+      !self.methods.include? :yml_file
+    end
+    def method_missing(method, *key)
+      if key.empty?
+        if contracts.has_key?(method)
+          contracts[method]
+          elsif methods.include?(:each) && each.methods.include?(method)
+              self.each.send method
+          else
+          error "contract #{method} not defined. Try »all« for a list of defined Contracts.", :symbol
+        end
+      else
+        error "method missing"
+      end
+    end
+
+    def all
+      contracts.keys.sort rescue contracts.keys
+    end
+    def print_all
+      puts contracts.sort.map{|x,y| [x,y.description].join(" -> ")}.join "\n"
+    end
+    def contracts
+      if @contracts.present?
+        @contracts
+      else
+        @contracts = Hash.new
+      end
+    end
+    def [] symbol
+      if c=contracts[symbol]
+        return c
+      else
+        # symbol probably has not been predefined, tell user about it
+        file = self.to_s.split(/::/).last.downcase
+        msg = "Unknown symbol :#{symbol}, please pre-define it in lib/ib/symbols/#{file}.rb"
+        error msg, :symbol
+      end
+    end
+  end
+
+
+ Connection.current.activate_plugin "verify"
+ Connection.current.activate_plugin "roll"
+ Connection.current.activate_plugin "spread-prototypes"
+ [ :forex, :futures, :stocks, :index, :cfd, :commodity, :options, :combo, :bonds, :abstract ].each do  |pt|
+    Connection.current.activate_plugin "symbols/#{pt.to_s}"
+ end
+
+end
+

data/plugins/ib/verify.rb

@@ -0,0 +1,226 @@
+module IB
+=begin rdoc
+
+Plugin that provides Verifying a contract
+
+Public API
+==========
+
+Extends IB::Contract
+
+* verify
+
+  returns an array of suitable IB::Contracts
+```ruby
+     a  =  Stock.new symbol: 'AA'
+     aa =  a.verify.first
+```
+
+  an optional block may be used to modify and filter the tws-response
+
+```ruby
+     f = IB::Future.new  symbol: 'M2K'
+     con_ids =  f.verify{ |c| c.con_id }
+     =>  [412889018, 428519982, 446091466, 461318872, 477836981]
+```
+=end
+
+  module Verify
+
+
+    # IB::Contract#Verify
+
+    # verifies the contract
+    #
+    # returns the number of contracts returned by the TWS.
+    #
+    #
+    # The method accepts a block. The  queried contract-Object is accessible there.
+    # If multiple contracts are returned by the tws, the block is executed with each of these contracts.
+    #
+    #
+    # Verify returns an  _Array_ of contracts. The  operation leaves the contract untouched.
+    #
+    #
+    # Returns nil if the contract could not be verified.
+    #
+    #  > s =  Stock.new symbol: 'AA'
+    #     => #<IB::Stock:0x0000000002626cc0
+    #        @attributes={:symbol=>"AA", :con_id=>0, :right=>"", :include_expired=>false,
+    #                     :sec_type=>"STK", :currency=>"USD", :exchange=>"SMART"}
+    #  > sp  = s.verify.first.essential
+    #     => #<IB::Stock:0x00000000025a3cf8
+    #        @attributes={:symbol=>"AA", :con_id=>251962528, :exchange=>"SMART", :currency=>"USD",
+    #                     :strike=>0.0, :local_symbol=>"AA", :multiplier=>0, :primary_exchange=>"NYSE",
+    #                     :trading_class=>"AA", :sec_type=>"STK", :right=>"", :include_expired=>false}
+    #
+    #  > s =  Stock.new symbol: 'invalid'
+    #     =>  @attributes={:symbol=>"invalid", :sec_type=>"STK", :currency=>"USD", :exchange=>"SMART"}
+    #  >  sp  = s.verify
+    #     => []
+    #
+    # Takes a Block to modify the queried contracts
+    #
+    # f = Future.new  symbol: 'M2K'
+    # con_ids =  f.verify{ |c| c.con_id }
+    #   [412889018, 428519982, 446091466, 461318872, 477836981]
+    #
+    #
+    # Parameter: thread: (true/false)
+    #
+    # If multiple contracts are to be verified, they can be queried simultaneously.
+    #    IB::Symbols::W500.map{|c|  c.verify(thread: true){ |vc| do_something }}.join
+
+    def verify thread: nil, &b
+      if thread
+        Thread.new { _verify  &b }
+      else
+       i = 0
+       begin
+         _verify   &b
+       rescue IB::VerifyError
+         i += 1
+         if i < 3
+            sleep 1
+            retry
+         else
+            raise
+          end
+        end
+      end
+    end # def
+
+    # returns a hash
+    def necessary_attributes
+
+      v= { stock:  { currency: 'USD', exchange: 'SMART', symbol: nil},
+           option: { currency: 'USD', exchange: 'SMART', right: 'P', expiry: nil, strike: nil, symbol:  nil},
+           future: { currency: 'USD', exchange: nil, expiry: nil,  symbol: nil },
+           forex:  { currency: 'USD', exchange: 'IDEALPRO', symbol: nil }
+      }
+      sec_type.present? ? v[sec_type] : { con_id: nil, exchange: 'SMART' } # enables to use only con_id for verifying
+                                                                        # if the contract allows SMART routing
+    end
+
+    
+    private
+
+    # Base method to verify a contract
+    #
+    # if :thread is given, the method subscribes to messages, fires the request and returns the thread, that
+    # receives the exit-condition-message
+    #
+    # otherwise the method waits until the response form tws is processed
+    #
+    #
+    # if :update is true, the attributes of the Contract itself are adapted
+    #
+    # otherwise the Contract is untouched
+    def _verify  &b # :nodoc:
+      ib = Connection.current
+      error "No Connection"  unless ib.is_a? Connection
+      # we generate a Request-Message-ID on the fly
+      error "Either con_id or sec_type have to be set", :verify if con_id.to_i.zero?  && sec_type.blank?
+      # define local vars which are updated within the query-block
+      received_contracts = []
+      queue = Queue.new
+      message_id = nil
+
+      # a tws-request is suppressed for bags and if the contract_detail-record is present
+      tws_request_not_necessary = bag? || contract_detail.is_a?( ContractDetail )
+
+      if tws_request_not_necessary
+        yield self if block_given?
+        return [self]    # return an array!
+      else # subscribe to ib-messages and describe what to do
+        a = ib.subscribe(:Alert, :ContractData,  :ContractDataEnd) do |msg|
+          case msg
+          when Messages::Incoming::Alert
+            ## do not throw an error here, asynchronous operation!
+            ## just notice failure in log and return nil instead of contract-object
+            if msg.code == 200 && msg.error_id == message_id
+              ib.logger.error { "Not a valid Contract :: #{self.to_human} " }
+              queue.push "InvalidContract"
+            end
+          when Messages::Incoming::ContractData
+            if msg.request_id.to_i == message_id
+              c = if block_given?
+                           yield msg.contract
+                     else
+                           msg.contract
+                   end
+              queue.push c unless c.nil?
+            end
+          when Messages::Incoming::ContractDataEnd
+            queue.close if  msg.request_id.to_i == message_id
+          end  # case
+        end # subscribe
+
+        ### send the request !
+        # contract_to_be_queried =  con_id.present? ? self : query_contract
+        # if no con_id is present,  the given attributes are checked by query_contract
+        # if contract_to_be_queried.present?   # is nil if query_contract fails
+        message_id = ib.send_message :RequestContractData, :contract => query_contract
+
+        Thread.new do 
+          (0 .. 10).each{ sleep 0.1 } 
+          queue.push "TimeOut"  unless queue.closed?
+         end
+
+        while r = queue.pop
+          if r.is_a? IB::Contract
+             received_contracts << r
+          else
+             error "No data received from IB-Servers", :verify  if r == "TimeOut"
+          end
+        end
+        ib.unsubscribe a
+      end
+      received_contracts   # return contracts
+    end
+
+    # Generates an IB::Contract with the required attributes to retrieve a unique contract from the TWS
+    #
+    # Background: If the tws is queried with a »complete« IB::Contract, it fails occasionally.
+    # So – even to update its contents, a defined subset of query-parameters  has to be used.
+    #
+    # The required data-fields are stored in a yaml-file and fetched by #YmlFile.
+    #
+    # If `con_id` is present, only `con_id` and `exchange` are transmitted to the tws.
+    # Otherwise a IB::Stock, IB::Option, IB::Future or IB::Forex-Object with necessary attributes
+    # to query the tws is build (and returned)
+    #
+    # If Attributes are missing, an IB::VerifyError is fired,
+    # This can be trapped with 
+    #   rescue IB::VerifyError do ...
+
+    def  query_contract( invalid_record: true )  # :nodoc:
+      # don't raise a verify error at this time. Contract.new con_id= xxxx, currency = 'xyz' is also valid
+      ##  raise VerifyError, "Querying Contract failed: Invalid Security Type" unless SECURITY_TYPES.values.include? sec_type
+
+      ## the yml contains symbol-entries
+      ## these are converted to capitalized strings
+      items_as_string = ->(i){i.map{|x,y| x.to_s.capitalize}.join(', ')}
+      ## here we read the corresponding attributes of the specified contract
+      item_values = ->(i){ i.map{|x,y| self.send(x).presence || y }}
+      ## and finally we create a attribute-hash to instantiate a new Contract
+      ## to_h is present only after ruby 2.1.0
+      item_attributehash = ->(i){ i.keys.zip(item_values[i]).to_h }
+      ## now lets proceed, but only if no con_id is present
+      if con_id.blank? || con_id.zero?
+        #       if item_values[necessary_attributes].any?( &:nil? )
+        #         raise VerifyError, "#{items_as_string[necessary_attributes]} are needed to retrieve Contract,
+        #                                 got: #{item_values[necessary_attributes].join(',')}"
+        #       end
+        #     Contract.build  item_attributehash[necessary_items].merge(:sec_type=> sec_type)  # return this
+        Contract.build  self.invariant_attributes # return this
+      else   # its always possible, to retrieve a Contract if con_id and exchange  or are present
+        Contract.new  con_id: con_id , :exchange => exchange.presence || item_attributehash[necessary_attributes][:exchange].presence || 'SMART'        # return this
+      end  # if
+    end # def
+  end  # module verify
+
+class Contract
+  include Verify
+end
+end #module ib