ib-api 10.33.1

data/plugins/ib/connection-tools.rb

@@ -0,0 +1,122 @@
+module IB
+
+=begin
+Plugin for advanced Connections
+
+Public API
+==========
+
+Extends IB::Connection
+
+Provides
+ * IB::Connection.current.check_connection
+ * IB::Connection.current.safe_connect
+ * IB::Connection.reconect
+
+
+=end
+
+  module ConnectionTools
+    # Handy method to ensure that a connection is established and active.
+    #
+    # The connection is reset on the IB-side at least once a day. Then the
+    # IB-Ruby-Connection has to be reestablished, too.
+    #
+    # check_connection reconnects if necessary and returns false if the connection is lost.
+    #
+    # Individial subscriptions have to be placed **after** checking the connection!
+    #
+    # It delays the process by 6 ms (500 MBit Cable connection, loc. Europe)
+    #
+    #  a =  Time.now; IB::Connection.current.check_connection; b= Time.now ;b-a
+    #   => 0.00066005
+    #
+    def check_connection
+      q =  Queue.new
+      count = 0
+      result = nil
+      z= subscribe( :CurrentTime ) { q.push true }
+      loop do
+        begin
+          send_message(:RequestCurrentTime)                       # 10 ms  ##
+          th = Thread.new{ sleep 0.1 ; q.push nil }
+          result =  q.pop
+          count+=1
+          break if result || count > 10
+        rescue IOError, Errno::ECONNREFUSED   # connection lost
+          count +=1
+          retry
+        rescue IB::Error # not connected
+          logger.info{"not connected ... trying to reconnect "}
+          reconnect
+          z= subscribe( :CurrentTime ) { q.push true }
+          count = 0
+          retry
+        rescue Workflow::NoTransitionAllowed 
+          logger.warn{ "Reconnect is not possible, actual state: #{workflow_state} cannot be reached after disconnection"}
+          raise
+        end
+      end
+      unsubscribe z
+      result #  return value
+    end
+
+    #
+    # Tries to connect to the api. If the connection could not be established, waits
+    # 10 sec. or one minute and reconnects.
+    #
+    # Unsuccessful connecting attemps are logged.
+    #
+    #
+    protected
+    def try_connection maximal_count_of_retry=100
+
+      i= -1
+      begin
+        _try_connection
+      rescue  Errno::ECONNREFUSED => e
+        i+=1
+        if i < maximal_count_of_retry
+          if i.zero?
+            logger.info 'No TWS!'
+          else
+            logger.info {"No TWS        Retry #{i}/ #{maximal_count_of_retry} " }
+          end
+          sleep i<50 ? 10 : 60   # Die ersten 50 Versuche im 10 Sekunden Abstand, danach 1 Min.
+          retry
+        else
+          logger.info { "Giving up!!"  }
+          return false
+        end
+      rescue Errno::EHOSTUNREACH => e
+        error "Cannot connect to specified host  #{e}", :reader, true
+        return false
+      rescue SocketError => e
+        error 'Wrong Adress, connection not possible', :reader, true
+        return false
+      rescue IB::Error => e
+        logger.info e
+      end
+      self #  return connection
+    end # def
+
+    def submit_to_alert_1102
+      current.subscribe( :Alert ) do
+        if [2102, 1101].include? msg.id.to_i # Connectivity between IB and Trader Workstation
+                                 #has been restored - data maintained.
+          current.disconnect!
+          sleep 0.1
+          current.check_connection
+        end
+      end
+
+    end
+  end
+
+  class Connection
+    alias _try_connection try_connection
+    include ConnectionTools
+  end
+
+
+end

data/plugins/ib/eod.rb

@@ -0,0 +1,326 @@
+module IB
+require 'active_support/core_ext/date/calculations'
+require 'csv'
+
+=begin
+
+Plugin to support EndOfDay OHLC-Data for a contract
+
+Public API
+==========
+
+Extends IB::Contract
+
+* eod
+
+  * request  EndOfDay historical data
+
+  * returns an Array of OHLC-EOD-Records or a Polars-Dataframe populated with OHLC-Records for the contract
+    and populates IB::Contract#bars
+
+
+* get_bars
+
+  * request historical data for custom ohlc-timeframes,
+
+* from_csv and to_csv
+
+  *  store and retrieve ohlc-data
+
+
+=end
+
+ module Eod
+  module BuisinesDays
+  # https://stackoverflow.com/questions/4027768/calculate-number-of-business-days-between-two-days
+
+    # Calculates the number of business days in range (start_date, end_date]
+    #
+    # @param start_date [Date]
+    # @param end_date [Date]
+    #
+    # @return [Fixnum]
+    def self.business_days_between(start_date, end_date)
+      days_between = (end_date - start_date).to_i
+      return 0 unless days_between > 0
+
+                # Assuming we need to calculate days from 9th to 25th, 10-23 are covered
+                # by whole weeks, and 24-25 are extra days.
+                #
+                # Su Mo Tu We Th Fr Sa    # Su Mo Tu We Th Fr Sa
+                #        1  2  3  4  5    #        1  2  3  4  5
+                #  6  7  8  9 10 11 12    #  6  7  8  9 ww ww ww
+                # 13 14 15 16 17 18 19    # ww ww ww ww ww ww ww
+                # 20 21 22 23 24 25 26    # ww ww ww ww ed ed 26
+                # 27 28 29 30 31          # 27 28 29 30 31
+                    whole_weeks, extra_days = days_between.divmod(7)
+
+                    unless extra_days.zero?
+                # Extra days start from the week day next to start_day,
+                # and end on end_date's week date. The position of the
+                # start date in a week can be either before (the left calendar)
+                # or after (the right one) the end date.
+                #
+                # Su Mo Tu We Th Fr Sa    # Su Mo Tu We Th Fr Sa
+                #        1  2  3  4  5    #        1  2  3  4  5
+                #  6  7  8  9 10 11 12    #  6  7  8  9 10 11 12
+                # ## ## ## ## 17 18 19    # 13 14 15 16 ## ## ##
+                # 20 21 22 23 24 25 26    # ## 21 22 23 24 25 26
+                # 27 28 29 30 31          # 27 28 29 30 31
+                #
+                # If some of the extra_days fall on a weekend, they need to be subtracted.
+                # In the first case only corner days can be days off,
+                # and in the second case there are indeed two such days.
+                      extra_days -= if start_date.tomorrow.wday <= end_date.wday
+                                      [start_date.tomorrow.sunday?, end_date.saturday?].count(true)
+                                    else
+                                      2
+                                    end
+                    end
+
+                    (whole_weeks * 5) + extra_days
+    end
+  end
+    
+    # eod 
+    #
+    # Receive EOD-Data and store the data in the `:bars`-property of IB::Contract
+    #
+    # contract.eod duration: {String or Integer}, start: {Date}, to: {Date}, what: {see below},  polars: {true|false}
+    #
+    #
+    #
+    # The Enddate has to be specified (as Date Object), `:to`,  default: Date.today
+    #
+    # The Duration can either be a String "yx D", "yd W", "yx M" or an Integer ( implies "D").
+    #  *notice*  "W"  fetchtes weekly  and "M" monthly bars
+    #
+    # A start date can be  given with the `:start` parameter.
+    #
+    # The parameter `:what` specifies the kind of received data.
+    #
+    #  Valid values:   ( /lib/ib/constants.rb --> DATA_TYPES )
+    #   :trades, :midpoint, :bid, :ask, :bid_ask,
+    #   :historical_volatility, :option_implied_volatility,
+    #   :option_volume, :option_open_interest
+    #
+    # Polars DataFrames
+    # -----------------
+    # If »polars: true« is specified the response is stored as PolarsDataframe.
+    # For further processing: https://github.com/ankane/polars-ruby
+    #                         https://pola-rs.github.io/polars/py-polars/html/index.html
+    #
+    # Error-handling
+    # --------------
+    # * Basically all Errors simply lead to log-entries:
+    # * the contract is not valid,
+    # * no market data subscriptions
+    # * other servers-side errors
+    #
+    # If the duration is longer then the maximum range, the response is
+    # cut to the maximum allowed range
+    #
+    # Customize the result
+    # --------------------
+    # The results are stored in the `:bars` property of the contract
+    #
+    #
+    # Limitations
+    # -----------
+    # To identify a request, the con_id of the asset is used
+    # Thus, parallel requests of a single asset with different time-frames will fail
+    #
+    # Examples
+    # --------
+    #
+    # puts  Stock.new( symbol: :iwm).eod( start: Date.new(2019,10,9), duration: 3, polars: true)
+        # shape: (3, 8)
+        # ┌────────────┬────────┬────────┬────────┬────────┬────────┬─────────┬────────┐
+        # │ time       ┆ open   ┆ high   ┆ low    ┆ close  ┆ volume ┆ wap     ┆ trades │
+        # │ ---        ┆ ---    ┆ ---    ┆ ---    ┆ ---    ┆ ---    ┆ ---     ┆ ---    │
+        # │ date       ┆ f64    ┆ f64    ┆ f64    ┆ f64    ┆ i64    ┆ f64     ┆ i64    │
+        # ╞════════════╪════════╪════════╪════════╪════════╪════════╪═════════╪════════╡
+        # │ 2019-10-08 ┆ 148.62 ┆ 149.37 ┆ 146.11 ┆ 146.45 ┆ 156625 ┆ 146.831 ┆ 88252  │
+        # │ 2019-10-09 ┆ 147.18 ┆ 148.0  ┆ 145.38 ┆ 145.85 ┆ 94337  ┆ 147.201 ┆ 51294  │
+        # │ 2019-10-10 ┆ 146.9  ┆ 148.74 ┆ 146.87 ┆ 148.24 ┆ 134549 ┆ 147.792 ┆ 71084  │
+        # └────────────┴────────┴────────┴────────┴────────┴────────┴─────────┴────────┘
+        #
+    # puts  Stock.new( symbol: :iwm).eod( start: Date.new(2021,10,9), duration: '3W', polars: true)
+        # shape: (3, 8)
+        # ┌────────────┬────────┬────────┬────────┬────────┬─────────┬─────────┬────────┐
+        # │ time       ┆ open   ┆ high   ┆ low    ┆ close  ┆ volume  ┆ wap     ┆ trades │
+        # │ ---        ┆ ---    ┆ ---    ┆ ---    ┆ ---    ┆ ---     ┆ ---     ┆ ---    │
+        # │ date       ┆ f64    ┆ f64    ┆ f64    ┆ f64    ┆ i64     ┆ f64     ┆ i64    │
+        # ╞════════════╪════════╪════════╪════════╪════════╪═════════╪═════════╪════════╡
+        # │ 2021-10-01 ┆ 223.99 ┆ 227.68 ┆ 216.12 ┆ 222.8  ┆ 1295495 ┆ 222.226 ┆ 792711 │
+        # │ 2021-10-08 ┆ 221.4  ┆ 224.95 ┆ 216.76 ┆ 221.65 ┆ 1044233 ┆ 220.855 ┆ 621984 │
+        # │ 2021-10-15 ┆ 220.69 ┆ 228.41 ┆ 218.94 ┆ 225.05 ┆ 768065  ┆ 223.626 ┆ 437817 │
+        # └────────────┴────────┴────────┴────────┴────────┴─────────┴─────────┴────────┘
+        #
+    # puts  Stock.new( symbol: :iwm).eod( start: Date.new(2022,10,1), duration: '3M', polars: true)
+        # shape: (3, 8)
+        # ┌────────────┬────────┬────────┬────────┬────────┬─────────┬─────────┬─────────┐
+        # │ time       ┆ open   ┆ high   ┆ low    ┆ close  ┆ volume  ┆ wap     ┆ trades  │
+        # │ ---        ┆ ---    ┆ ---    ┆ ---    ┆ ---    ┆ ---     ┆ ---     ┆ ---     │
+        # │ date       ┆ f64    ┆ f64    ┆ f64    ┆ f64    ┆ i64     ┆ f64     ┆ i64     │
+        # ╞════════════╪════════╪════════╪════════╪════════╪═════════╪═════════╪═════════╡
+        # │ 2022-09-30 ┆ 181.17 ┆ 191.37 ┆ 162.77 ┆ 165.16 ┆ 4298969 ┆ 175.37  ┆ 2202407 │
+        # │ 2022-10-31 ┆ 165.5  ┆ 184.24 ┆ 162.5  ┆ 183.5  ┆ 4740014 ┆ 173.369 ┆ 2474286 │
+        # │ 2022-11-30 ┆ 184.51 ┆ 189.56 ┆ 174.11 ┆ 188.19 ┆ 3793861 ┆ 182.594 ┆ 1945674 │
+        # └────────────┴────────┴────────┴────────┴────────┴─────────┴─────────┴─────────┘
+        #
+    # puts  Stock.new( symbol: :iwm).eod( start: Date.new(2020,1,1), duration: '3M', what: :option_implied_vol, polars: true
+        # atility )
+        # shape: (3, 8)
+        # ┌────────────┬──────────┬──────────┬──────────┬──────────┬────────┬──────────┬────────┐
+        # │ time       ┆ open     ┆ high     ┆ low      ┆ close    ┆ volume ┆ wap      ┆ trades │
+        # │ ---        ┆ ---      ┆ ---      ┆ ---      ┆ ---      ┆ ---    ┆ ---      ┆ ---    │
+        # │ date       ┆ f64      ┆ f64      ┆ f64      ┆ f64      ┆ i64    ┆ f64      ┆ i64    │
+        # ╞════════════╪══════════╪══════════╪══════════╪══════════╪════════╪══════════╪════════╡
+        # │ 2019-12-31 ┆ 0.134933 ┆ 0.177794 ┆ 0.115884 ┆ 0.138108 ┆ 0      ┆ 0.178318 ┆ 0      │
+        # │ 2020-01-31 ┆ 0.139696 ┆ 0.190494 ┆ 0.120646 ┆ 0.185732 ┆ 0      ┆ 0.19097  ┆ 0      │
+        # │ 2020-02-28 ┆ 0.185732 ┆ 0.436549 ┆ 0.134933 ┆ 0.39845  ┆ 0      ┆ 0.435866 ┆ 0      │
+        # └────────────┴──────────┴──────────┴──────────┴──────────┴────────┴──────────┴────────┘
+        #
+        def eod start: nil, to: nil, duration: nil , what: :trades, polars: false
+
+         # error "EOD:: Start-Date (parameter: to) must be a Date-Object" unless to.is_a? Date
+          normalize_duration = ->(d) do
+            error "incompatible duration: #{d.class}" unless d.is_a?(Integer) || d.is_a?(String)
+            if d.is_a?(Integer) || !["D","M","W","Y"].include?( d[-1].upcase )
+              d.to_i.to_s + "D"
+            else
+              d.gsub(" ","")
+            end.insert(-2, " ")
+          end
+
+          get_end_date = -> do
+            d = normalize_duration.call(duration)
+            case  d[-1]
+            when "D"
+              start + d.to_i - 1
+            when 'W'
+              Date.commercial( start.year, start.cweek + d.to_i - 1, 1)
+            when 'M'
+              Date.new( start.year, start.month + d.to_i - 1 , start.day )
+            end
+          end
+
+          if to.nil?
+          #  case   eod start= Date.new ...
+            to =   if start.present? && duration.nil?
+          # case    eod start= Date.new
+                     duration = BuisinesDays.business_days_between(start, Date.today).to_s + "D"
+                     Date.today #  assign to var: to
+                   elsif start.present? && duration.present?
+          # case    eod start= Date.new , duration: 'nN'
+                     get_end_date.call  # assign to var: to
+                   elsif duration.present?
+          # case    start is not present, we are collecting until the present day
+                      Date.today         # assign to var: to
+                   else
+                     duration =  "1D"
+                     Date.today
+                   end
+          end
+          if duration.nil?
+            duration = BuisinesDays.business_days_between(start, to)
+          end
+
+          barsize = case normalize_duration.call(duration)[-1].upcase
+                    when "W"
+                      :week1
+                    when "M"
+                      :month1
+                    else
+                      :day1
+                    end
+
+
+         get_bars( to.to_ib(time_zone) , normalize_duration[duration], barsize, what, polars )
+
+        end # def
+
+    # creates (or overwrites) the specified file (or symbol.csv) and saves bar-data
+    def to_csv file: "#{symbol}.csv"
+      if bars.present?
+        headers = bars.first.invariant_attributes.keys
+        CSV.open( file, 'w' ) {|f| f << headers ; bars.each {|y| f << y.invariant_attributes.values } }
+      end
+    end
+
+    # read csv-data into bars
+    def from_csv file: nil
+      file ||=  "#{symbol}.csv"
+      self.bars = []
+      CSV.foreach( file,  headers: true, header_converters: :symbol) do |row|
+        self.bars << IB::Bar.new( **row.to_h )
+      end
+    end
+
+# get_bars::  Helper method to fetch historical data 
+# 
+# parameter:  end_date_time:: A string representing the last datum to fetch. 
+#                             Date.to_ib and Time.to_ib  return the correct format
+#             duration::      A String "yx D", "yd W", "yx M" 
+#             barsize::       A valid BAR_SIZES-entry  (/lib/ib/constants.rb)
+#             what_to_show::  A valid DATA_TYPES-entry (/lib/ib/constants.rb)
+#             polars::        Flag to indicate if a polars-dataframe should be returned 
+
+    def get_bars(end_date_time, duration, bar_size, what_to_show, polars)
+
+      tws = IB::Connection.current
+      received =  Queue.new
+      r = nil
+      # the hole response is transmitted at once!
+      a = tws.subscribe(IB::Messages::Incoming::HistoricalData) do |msg|
+        if msg.request_id == con_id
+          self.bars = if polars
+                        # msg.results.each { |entry| puts "  #{entry}" }
+                        Polars::DataFrame.new  msg.results.map( &:invariant_attributes )
+                      else
+                        msg.results
+                      end
+        end
+        received.push Time.now
+      end
+      b = tws.subscribe( IB::Messages::Incoming::Alert) do  |msg|
+        if [321,162,200,354].include? msg.code
+          tws.logger.warn msg.message
+          # TWS Error 200: No security definition has been found for the request
+          # TWS Error 354: Requested market data is not subscribed.
+          # TWS Error 162: Historical Market Data Service error
+          # TWS Error 321: Error validating request.-'bK' : cause - 
+          #                Historical data requests for durations longer than 365 days must be made in years.
+            
+          received.close
+        end
+      end
+
+
+      tws.send_message IB::Messages::Outgoing::RequestHistoricalData.new(
+        :request_id => con_id,
+        :contract =>  self,
+        :end_date_time => end_date_time,
+        :duration => duration, # see ib/messages/outgoing/bar_request.rb => max duration for 5sec bar lookback is 10 000 - i.e. will yield 2000 bars
+        :bar_size =>  bar_size, #  IB::BAR_SIZES.key(:hour)
+        :what_to_show => what_to_show,
+        :use_rth => 0,
+        :format_date => 2,
+        :keep_up_todate => 0)
+
+      received.pop # blocks until a message is ready on the queue or the queue is closed
+
+      tws.unsubscribe a
+      tws.unsubscribe b
+
+      block_given? ?  bars.map{|y| yield y} : bars  # return bars or result of block
+
+    end # def
+  end # module eod
+
+  class Contract
+    include Eod
+  end  # class
+end # module IB
+

data/plugins/ib/greeks.rb

@@ -0,0 +1,102 @@
+module IB
+=begin
+
+Plugin to fetch Option Greeks
+
+Provides Option.request_greeks and
+         Option.greeks  to display the fetched data
+
+=end
+
+ module Greeks
+
+# Ask for the Greeks and implied Vola
+#
+# The result can be customized by a provided block.
+#
+# IB::Symbols::Options.aapl.greeks{ |x| x }
+# -> {"bid"=>0.10142e3, "ask"=>0.10144e3, "last"=>0.10142e3, "close"=>0.10172e3}
+#
+#   Possible values for Parameter :what --> :all :model, :bid, :ask, :bidask, :last
+#
+   def request_greeks delayed:  true, what: :model, thread: false
+
+     tws = Connection.current    # get the initialized ib-ruby instance
+     # define requested tick-attributes
+     request_data_type = IB::MARKET_DATA_TYPES.rassoc( delayed ? :frozen_delayed : :frozen ).first
+     # possible types = [ [ :delayed_model_option , :model_option ] , [:delayed_last_option , :last_option ],
+     # [ :delayed_bid_option , :bid_option ], [ :delayed_ask_option , :ask_option ]]
+     tws.send_message :RequestMarketDataType, :market_data_type =>  request_data_type
+     tickdata = []
+
+     self.greek = OptionDetail.new if greek.nil?
+     greek.updated_at = Time.now
+     greek.option = self
+     queue =  Queue.new
+
+     #keep the method-call running until the request finished
+     #and cancel subscriptions to the message handler
+     # method returns the (running) thread
+     th = Thread.new do
+       the_id  =  nil
+       # subscribe to TickPrices
+       s_id = tws.subscribe(:TickSnapshotEnd) { |msg| queue.push(true)  if msg.ticker_id == the_id  }
+       e_id = tws.subscribe(:Alert){|x| queue.push(false)  if [200,353].include?( x.code) && x.error_id == the_id }
+       t_id = tws.subscribe( :TickSnapshotEnd, :TickPrice, :TickString, :TickSize, :TickGeneric, :MarketDataType, :TickRequestParameters  ) {|msg| msg }
+       # TWS Error 200: No security definition has been found for the request
+       # TWS Error 354: Requested market data is not subscribed.
+
+       sub_id = tws.subscribe(:TickOption ) do |msg| #, :TickSize,  :TickGeneric  do |msg|
+         if  msg.ticker_id == the_id # && tickdata.is_a?(Array) # do nothing if tickdata have already gathered
+           case msg.type
+           when /ask/
+             greek.ask_price = msg.option_price unless msg.option_price.nil?
+             tickdata << msg  if [ :all, :ask, :bidask ].include?( what )
+
+           when /bid/
+             greek.bid_price = msg.option_price unless msg.option_price.nil?
+             tickdata << msg  if [ :all, :bid, :bidask ].include?( what )
+           when /last/
+             tickdata << msg  if msg.type =~ /last/
+           when /model/
+             #  transfer attributs from TickOption to OptionDetail
+             bf =[ :option_price, :implied_volatility, :under_price, :pv_dividend ]
+             (bf + msg.greeks.keys).each{ |a| greek.send( a.to_s+"=", msg.send( a)) }
+             tickdata << msg  if [ :all, :model ].include?( what  )
+           end
+           # fast entry abortion ---> daiabled for now
+         #  queue.push(true) if tickdata.is_a?(IB::Messages::Incoming::TickOption) || (tickdata.size == 2 && what== :bidask) || (tickdata.size == 4 && what == :all)
+         end
+       end  # if sub_id
+
+       # initialize »the_id« that is used to identify the received tick messages
+       # by firing the market data request
+       iji = 0
+       loop do
+         the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true
+
+         result = queue.pop
+         # reduce :close_price delayed_close  to close a.s.o
+         if result == false
+           Connection.logger.info{ "#{to_human} --> No Marketdata received " }
+         else
+           self.misc =  tickdata if thread  # store internally if in thread modus
+         end
+         break if  !tickdata.empty?  ||  iji > 10
+         iji =  iji + 1
+         Connection.logger.info{ "OptionGreeks::#{to_human} --> delayed processing. Trying again (#{iji}) " }
+       end
+       tws.unsubscribe sub_id, s_id, e_id, t_id
+     end  # thread
+     if thread
+       th   # return thread
+     else
+       th.join
+       greek
+     end
+   end
+ end
+ class Option
+   include Greeks
+ end
+end