ib-api 10.33.1

data/plugins/ib/managed-accounts.rb

@@ -0,0 +1,274 @@
+module IB
+
+=begin
+
+Plugin for Managed Accounts
+
+Provides `clients` and `advisor` objects (Type: IB::Account) that contain account-specific data.
+
+Public Api
+==========
+
+* InitializeManagedAccounts
+ *  populates @accounts through RequestFA
+ *  should be called instead of  `connect`
+
+
+* GetAccountData
+ * requests account- and portfolio-data and associates them to the clients
+
+* provides
+   * client.account_values
+   * client.portfolio_values
+   * client.contracts
+
+
+The plugin should be activated **before** the connection attempt.
+
+**IB::Connection.current.initialize_manage_acounts performs a `connect` to the tws-server**`
+
+
+Standard usage
+
+  ib = IB::Connection.new 
+  ib.activate_plugin 'managed-accounts'
+  ib.initialize_managed_accounts!             #  connects to the tws
+  ib.get_account_data                        #  populates c.clients
+  account = ib.clients.first
+  puts account.portfolio_values.as_table
+
+=end
+
+module ManagedAccounts
+
+
+=begin
+clients returns a list of Account-Objects
+
+If only one Account is present,  Client and Advisor are identical.
+=end
+    def  clients
+      @accounts.find_all &:user?
+    end
+
+# is the account a financial advisor
+    def fa?
+      !(advisor == clients.first)
+    end
+
+
+=begin
+ The Advisor is always the first account
+=end
+     def advisor
+       @accounts.first
+     end
+
+
+=begin
+--------------------------- GetAccountData --------------------------------------------
+Queries for Account- and PortfolioValues
+The parameter can either be the account_id, the IB::Account-Object or
+an Array of account_id and IB::Account-Objects.
+
+Resets Account#portfolio_values and -account_values
+
+Raises an IB::TransmissionError if the account-data are not transmitted in time (1 sec)
+
+Raises an IB::Error if less then 100 items are received.
+=end
+  def get_account_data  *accounts, **compatibily_argument
+
+    subscription = subscribe_account_updates( continuously: false )
+    download_end = nil  # declare variable
+    received_array_status = received
+    self.received = false
+
+    accounts = clients if accounts.empty?
+    logger.warn{ "No active account present. AccountData are NOT requested" } if accounts.empty?
+    # Account-infos have to be requested sequentially.
+    # subsequent (parallel) calls kill the former on the tws-server-side
+    # In addition, there is no need to cancel the subscription of an request, as a new
+    # one overwrites the active one.
+    accounts.each do | ac |
+      account =  ac.is_a?( IB::Account ) ?  ac  : clients.find{|x| x.account == ac }
+      error( "No Account detected " )  unless account.is_a? IB::Account
+      # don't repeat the query until 170 sec. have passed since the previous update
+      if account.last_updated.nil?  || ( Time.now - account.last_updated ) > 170 # sec
+        logger.debug{ "#{account.account} :: Erasing Account- and Portfolio Data " }
+        logger.debug{ "#{account.account} :: Requesting AccountData " }
+
+        q =  Queue.new
+        download_end = subscribe( :AccountDownloadEnd )  do | msg |
+          q.push true if msg.account_name == account.account
+        end
+        # reset account and portfolio-values
+        account.portfolio_values = []
+        account.account_values = []
+        # Data are gathered asynchron through the active subscription defined in  `subscribe_account_updates`
+        send_message :RequestAccountData, subscribe: true, account_code: account.account
+
+        th =  Thread.new{   sleep 10 ; q.close  }  # close the queue after 10 seconds
+        q.pop                                      # wait for the data (or the closing event)
+
+        if q.closed?
+          error "No AccountData received", :reader
+        else
+          q.close
+          unsubscribe download_end
+        end
+
+#        account.organize_portfolio_positions  unless IB::Gateway.current.active_watchlists.empty?
+      else
+        logger.info{ "#{account.account} :: Using stored AccountData " }
+      end
+    end
+    send_message :RequestAccountData, subscribe: false  ## do this only once
+    unsubscribe subscription
+
+    self.received = received_array_status
+  rescue IB::TransmissionError => e
+        unsubscribe download_end unless download_end.nil?
+        unsubscribe subscription
+        raise
+  end
+
+
+  def all_contracts
+    clients.map(&:contracts).flat_map(&:itself).uniq(&:con_id)
+  end
+
+
+=begin
+--------------------------- InitializeManageAccounts ----------------------------------
+
+If initiated with the parameter `force: true`, any active connection is terminated.
+All subscriptiona are lost. The connection ist then re-established to initiate the
+transmission of available managed-accounts by the tws.
+
+=end
+  protected
+    def initialize_managed_accounts( force: false )
+     queue =  Queue.new
+     if connected?
+       disconnect!
+       sleep(0.1)
+     end
+     try_connection!
+     @accounts = []
+     # Ensure reader thread is running to process messages
+     start_reader unless reader_running?
+     # in case of advisor-accounts:  proper initialiastion of account records
+      rec_id = subscribe( :ReceiveFA )  do |msg|
+        msg.accounts.each do |a|
+          account_data( a.account ){| the_account | the_account.update_attribute :alias, a.alias } unless a.alias.blank?
+        end
+        logger.info { "Accounts initialized \n #{@accounts.map( &:to_human  ).join " \n " }" }
+        queue.push(true)
+      end
+
+      # initialisation of Account after a successful connection
+      man_id = subscribe( :ManagedAccounts ) do |msg|
+        @accounts =  msg.accounts
+        send_message( :RequestFA, fa_data_type: 3)
+      end
+
+      # single accounts return an alert message
+      error_id =  subscribe( :Alert ){|x| queue.push(false) if x.code == 321 }
+
+      # Add timeout to prevent deadlock - wait up to 10 seconds for response
+      timeout_thread = Thread.new { sleep 10; queue.push(:timeout) unless queue.closed? }
+      result = queue.pop
+      timeout_thread.kill if timeout_thread.alive?
+      timeout_thread.join rescue nil
+
+      if result == :timeout
+        error "Timeout waiting for account initialization", :reader
+        unsubscribe man_id, rec_id, error_id
+        raise IB::TransmissionError, "Timeout waiting for ManagedAccounts/ReceiveFA messages"
+      end
+
+      unsubscribe man_id, rec_id, error_id
+
+      @accounts
+
+    end # def
+
+  # The subscription method should called only once per session.
+  # It places subscribers to AccountValue and PortfolioValue Messages, which should remain
+  # active through the session.
+  #
+  # The method returns the subscription-number.
+  #
+  # thus
+  #    subscription =  subscribe_account_updates
+  #    #  some code
+  #    IB::Connection.current.unsubscribe subscription
+  #
+  # clears the subscription
+  #
+
+    private
+  def subscribe_account_updates continuously: true
+
+    add_or_update = ->(apv, new_hash) do
+      existing_index = apv.index { |h| h.contract.con_id == new_hash.contract.con_id }
+        if existing_index
+          apv[existing_index] = new_hash
+        else
+          apv << new_hash
+        end
+     end
+    subscribe( :AccountValue, :PortfolioValue,:AccountDownloadEnd )  do | msg |
+      account_data( msg.account_name ) do | account |   # enter mutex controlled zone
+        case msg
+        when IB::Messages::Incoming::AccountValue
+          account.account_values << msg.account_value
+          account.update_attribute :last_updated, Time.now
+          IB::Connection.logger.debug { "#{account.account} :: #{msg.account_value.to_human }"}
+        when IB::Messages::Incoming::AccountDownloadEnd
+          if account.account_values.size > 10
+            account.update_attribute :connected, true   ## flag: Account is completely initialized
+            IB::Connection.logger.info { "#{account.account} => Count of AccountValues: #{account.account_values.size}"  }
+          else # unreasonable account_data received -  request is still active
+            error  "#{account.account} => Count of AccountValues too small: #{account.account_values.size}" , :reader
+          end
+        when IB::Messages::Incoming::PortfolioValue
+          account.contracts << msg.contract unless account.contracts.detect{|y| y.con_id == msg.contract.con_id }
+          add_or_update[account.portfolio_values,msg.portfolio_value]
+          IB::Connection.logger.debug { "#{ account.account } :: #{ msg.contract.to_human }" }
+        end # case
+      end # account_data
+    end # subscribe
+  end  # def
+  # safe access to account-data
+  def account_data account_or_id=nil
+
+    if account_or_id.present?
+      account = account_or_id.is_a?(IB::Account) ? account_or_id :  @accounts.detect{|x| x.account == account_or_id }
+      yield account
+    else
+      @accounts.map{|a| yield a}
+    end
+
+  end
+
+  alias activate_managed_accounts subscribe_account_updates
+
+
+  end
+
+  class Connection
+    include ManagedAccounts
+    # Note: Automatic initialization may need to be removed if the program becomes unstable.
+    # This automatic call to activate_managed_accounts! can cause race conditions and deadlocks,
+    # particularly when the plugin is loaded mid-session. Consider removing this automatic
+    # initialization and requiring users to explicitly call initialize_managed_accounts! when needed.
+    current.activate_managed_accounts!
+  rescue  Workflow::NoTransitionAllowed => e
+    if current.workflow_state == :ready
+      current.disconnect!
+      resume
+    end
+  end
+end

data/plugins/ib/market-price.rb

@@ -0,0 +1,150 @@
+module IB
+
+ module MarketPrice
+   # Ask for the Market-Price
+   #
+   # For valid contracts, either bid/ask or last_price and close_price are transmitted.
+   #
+   # If last_price is received, its returned.
+   # If not, midpoint (bid+ask/2) is used. Else the closing price will be returned.
+   #
+   # Any  value (even 0.0) which is stored in IB::Contract.misc indicates that the contract is
+   # accepted by `request_market_data` and will be accepted by `place_order`, too.
+   #
+   # The result can be customized by a provided block.
+   #
+   # ```ruby
+   # IB::Symbols::Stocks.sie.market_price{ |x| x }
+   # -> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
+   # ```
+   #
+   #
+   # Raw-data are stored in the _bars_-property of IB::Contract
+   # (volatile, ie. data are not preserved when the Object is reused via Contract#merge)
+   #
+   # ```ruby
+   #  u= (z1=IB::Stock.new(symbol: :ge)).market_price
+   #  A: Requested market data is not subscribed. Displaying delayed market data.
+   #  > u  => 0.16975e3
+   #  > z1 => #<IB::Stock:0x00007f91037f0e18
+   #         @attributes= { :symbol =>"ge", (...)
+   #                      :currency => "USD",
+   #                      :exchange => "SMART" },
+   #         @bars = [ { last: -0.1e1, close: 0.16975e3, bid: -0.1e1, ask: -0.1e1 } ],
+   #         @misc = { delayed: 0.16975e3 }
+   #
+   # ```
+   #
+   # Fetching of market-data is a time consuming process. A threaded approach is suitable
+   # to get a bunch of market-data in time
+   #
+   # ```ruby
+   #  th  = (z2 = IB::Stock.new(symbol: :ge)).market_price(thread: true)
+   #  th.join
+   # ```
+   # assigns z2.misc with the value of the :last (or delayed_last) TickPrice-Message
+   # and returns the thread.
+   #
+
+   def market_price delayed:  true, thread: false, no_error: false
+
+     tws=  Connection.current    # get the initialized ib-ruby instance
+     the_id , the_price =  nil, nil
+     tickdata =  Hash.new
+     q =  Queue.new
+     # define requested tick-attributes
+     last, close, bid, ask   =  [ [ :delayed_last , :last_price ] , [:delayed_close , :close_price ],
+                                 [  :delayed_bid , :bid_price ], [  :delayed_ask , :ask_price ]]
+     request_data_type = delayed ? :frozen_delayed :  :frozen
+
+     # From the tws-documentation (https://interactivebrokers.github.io/tws-api/market_data_type.html)
+     # Beginning in TWS v970, a IBApi.EClient.reqMarketDataType callback of 1 will occur automatically
+     # after invoking reqMktData if the user has live data permissions for the instrument.
+     #
+     # so - even if "delayed" is specified, realtime-data are returned if RT-permissions are present
+     #
+
+     # method returns the (running) thread
+     th = Thread.new do
+       # about 11 sec after the request, the TWS returns :TickSnapshotEnd if no ticks are transmitted
+       # we don't have to implement our own timeout-criteria
+       s_id = tws.subscribe(:TickSnapshotEnd){|x| q.push(true) if x.ticker_id == the_id }
+       a_id = tws.subscribe(:Alert){|x| q.push(x) if [200, 354, 10167, 10168].include?( x.code )  && x.error_id == the_id }
+       # TWS Error 354: Requested market data is not subscribed.
+
+       # subscribe to TickPrices
+       sub_id = tws.subscribe(:TickPrice ) do |msg| #, :TickSize,  :TickGeneric, :TickOption) do |msg|
+         [last,close,bid,ask].each do |x|
+           tickdata[x] = msg.the_data[:price] if x.include?( IB::TICK_TYPES[ msg.the_data[:tick_type]])
+           #  fast exit condition
+           q.push(true) if tickdata.size >= 4
+         end if  msg.ticker_id == the_id
+       end
+       # initialize »the_id« that is used to identify the received tick messages
+       # by firing the market data request
+       the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
+
+       while !q.closed? do
+         result = q.pop
+         if result.is_a? IB::Messages::Incoming::Alert
+           tws.logger.debug result.message
+           case result.code
+           when 200
+             q.close
+             error "#{to_human} --> #{result.message}"   unless no_error
+           when 354, #   not subscribed to market data
+             10167,
+             10168
+             if delayed && !(result.message =~ /market data is not available/)
+               tws.logger.debug  "#{to_human} --> requesting delayed data"
+               tws.send_message :RequestMarketDataType, :market_data_type => 3
+               self.misc = :delayed
+               sleep 0.1
+               the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
+             else
+               q.close
+               tws.logger.error "#{to_human} --> No marketdata permissions"  unless no_error
+             end
+           end
+         elsif result.present?
+           q.close
+           tz = -> (z){ z.map{|y| y.to_s.split('_')}.flatten.count_duplicates.max_by{|k,v| v}.first.to_sym}
+           data =  tickdata.map{|x,y| [tz[x],y]}.to_h
+           valid_data = ->(d){ !(d.to_i.zero? || d.to_i == -1) }
+           self.bars << data                      #  store raw data in bars
+           the_price = if block_given?
+                         yield data
+                         # yields {:bid=>0.10142e3, :ask=>0.10144e3, :last=>0.10142e3, :close=>0.10172e3}
+                       else # behavior if no block is provided
+                         if valid_data[data[:last]]
+                           data[:last]
+                         elsif valid_data[data[:bid]]
+                           (data[:bid]+data[:ask])/2
+                         elsif data[:close].present?
+                           data[:close]
+                         else
+                           nil
+                         end
+                       end
+
+           self.misc = misc == :delayed ? { :delayed =>  the_price }  : { realtime: the_price }
+         else
+           q.close
+           error "#{to_human} --> No Marketdata received "
+         end
+       end
+
+       tws.unsubscribe sub_id, s_id, a_id
+     end
+     if thread
+       th # return thread
+     else
+       th.join
+       the_price  # return
+     end
+   end #
+ end
+ class Contract
+   include MarketPrice
+ end
+end

data/plugins/ib/option-chain.rb

@@ -0,0 +1,167 @@
+module IB
+
+ module OptionChain
+
+  # returns the Option Chain  (monthly options, expiry: third friday)
+  # of the contract (if available)
+  #
+  #
+  ## parameters
+  ### right:: :call, :put, :straddle                ( default: :put )
+  ### ref_price::  :request or a numeric value      ( default:  :request )
+  ### sort:: :strike, :expiry
+  ### exchange:: List of Exchanges to be queried    ( default: SMART)
+  ### trading_class                                 ( optional )
+  def option_chain ref_price: :request, right: :put, sort: :strike, exchange: '', trading_class: nil
+
+    ib = Connection.current
+
+    # binary interthread communication
+    finalize = Queue.new
+
+    ## Enable Cashing of Definition-Matrix
+    @option_chain_definition ||= []
+
+    my_req = nil
+
+    # -----------------------------------------------------------------------------------------------------
+    # get OptionChainDefinition from IB ( instantiate cashed Hash )
+    if @option_chain_definition.blank?
+      sub_sdop = ib.subscribe( :SecurityDefinitionOptionParameterEnd ) { |msg| finalize.push(true) if msg.request_id == my_req }
+      sub_ocd = ib.subscribe( :OptionChainDefinition ) do | msg |
+        if msg.request_id == my_req
+          message = msg.data
+          # transfer the first record to @option_chain_definition
+          if @option_chain_definition.blank?
+            @option_chain_definition = msg.data
+          end
+          # override @option_chain_definition if a decent combination of attributes is met
+          # us- options:  use the smart dataset
+          # other options: prefer options of the default trading class
+#          if message[:exchange] == 'SMART'
+#            @option_chain_definition = msg.data
+#            finalize.push(true)
+#          end
+          if message[:trading_class] == symbol
+            @option_chain_definition = msg.data
+            finalize.push(true)
+          end
+        end
+      end
+
+      c = verify.first  #  ensure a complete set of attributes
+      my_req = ib.send_message :RequestOptionChainDefinition, con_id: c.con_id,
+        symbol: c.symbol,
+        exchange: c.sec_type == :future ? c.exchange : "", # BOX,CBOE',
+        sec_type: c[:sec_type]
+
+      finalize.pop #  wait until data appeared
+
+      ib.unsubscribe sub_sdop, sub_ocd
+    else
+      Connection.logger.info { "#{to_human} : using cached data" }
+    end
+
+    # -----------------------------------------------------------------------------------------------------
+    # select values and assign to options
+    #
+    unless @option_chain_definition.blank?
+      requested_strikes = if block_given?
+                             ref_price = market_price if ref_price == :request
+                             if ref_price.nil?
+                               ref_price = @option_chain_definition[:strikes].min +
+                                 ( @option_chain_definition[:strikes].max -
+                                  @option_chain_definition[:strikes].min ) / 2
+                               Connection.logger.warn { "#{to_human} :: market price not set – using midpoint of available strikes instead: #{ref_price.to_f}" }
+                             end
+                             atm_strike = @option_chain_definition[:strikes].min_by { |x| (x - ref_price).abs }
+                             the_grouped_strikes = @option_chain_definition[:strikes].group_by{|e| e <=> atm_strike}
+                             begin
+                               the_strikes = yield the_grouped_strikes
+                               the_strikes.unshift atm_strike unless the_strikes.first == atm_strike    # the first item is the atm-strike
+                               the_strikes
+                             rescue
+                               Connection.logger.error "#{to_human} :: not enough strikes :#{@option_chain_definition[:strikes].map(&:to_f).join(',')} "
+                               []
+                             end
+                           else
+                             @option_chain_definition[:strikes]
+                           end
+
+      # third Friday of a month
+      monthly_expirations = @option_chain_definition[:expirations].find_all {|y| (15..21).include? y.day }
+      #       puts @option_chain_definition.inspect
+      option_prototype = -> ( ltd, strike ) do
+        IB::Option.new( symbol: symbol,
+          exchange: @option_chain_definition[:exchange],
+          trading_class: @option_chain_definition[:trading_class],
+          multiplier: @option_chain_definition[:multiplier],
+          currency: currency,
+          last_trading_day: ltd,
+          strike: strike,
+          right: right).verify &.first
+      end
+      options_by_expiry = -> ( schema ) do
+        # Array: [ yymm -> Options] prepares for the correct conversion to a Hash
+        Hash[  monthly_expirations.map do | l_t_d |
+          [  l_t_d.strftime('%y%m').to_i , schema.map { | strike | option_prototype[ l_t_d, strike ]}.compact ]
+        end  ]                         # by Hash[ ]
+      end
+      options_by_strike = -> ( schema ) do
+        Hash[ schema.map do | strike |
+          [  strike ,   monthly_expirations.map { | l_t_d | option_prototype[ l_t_d, strike ]}.compact ]
+        end  ]                         # by Hash[ ]
+      end
+
+      if sort == :strike
+        options_by_strike[ requested_strikes ]
+      else
+        options_by_expiry[ requested_strikes ]
+      end
+    else
+      Connection.logger.error "#{to_human} ::No Options available"
+      nil # return_value
+    end
+  end  # def
+
+  # return a set of AtTheMoneyOptions
+  def atm_options ref_price: :request, right: :put, **params
+    option_chain(  right: right, ref_price: ref_price, sort: :expiry, **params) do | chain |
+      chain[0]
+    end
+
+
+  end
+
+  # return   InTheMoneyOptions
+  def itm_options count:  5, right: :put, ref_price: :request, sort: :strike, exchange: ''
+    option_chain(  right: right,  ref_price: ref_price, sort: sort, exchange: exchange ) do | chain |
+      if right == :put
+        above_market_price_strikes = chain[1][0..count-1]
+      else
+        below_market_price_strikes = chain[-1][-count..-1].reverse
+      end # branch
+    end
+  end   # def
+
+  # return OutOfTheMoneyOptions
+  def otm_options count:  5,  right: :put, ref_price: :request, sort: :strike, exchange: ''
+    option_chain( right: right, ref_price: ref_price, sort: sort, exchange: exchange ) do | chain |
+      if right == :put
+        #     puts "Chain: #{chain}"
+        below_market_price_strikes = chain[-1][-count..-1].reverse
+      else
+        above_market_price_strikes = chain[1][0..count-1]
+      end
+    end
+  end
+ end # module
+
+ Connection.current.activate_plugin 'verify'
+ Connection.current.activate_plugin 'market-price'
+
+ class Contract
+   include OptionChain
+ end
+
+end # module