ib-api 10.33.1

data/models/ib/index.rb

@@ -0,0 +1,14 @@
+module IB
+  class Index  < Contract
+    validates_format_of :sec_type, :with => /\Aind\z/,
+      :message => "should be a Index"
+    def default_attributes
+      super.merge :sec_type =>  'IND'
+    end
+    def to_human
+      "<Index: " + [symbol, currency].join(" ") + " (#{description}) >"
+    end
+
+  end
+  end
+

data/models/ib/option.rb

@@ -0,0 +1,149 @@
+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"
+
+
+    # introduce Option.greek with reference to IB::OptionDetail-dataset
+    #
+    has_one :greek , as: :option_detail
+    # 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 == other
+      super(other) || (  # finish positive, if contract#== is true
+                          # otherwise, we most probably compare the response from IB with our selfmade input
+      exchange == other.exchange &&
+      include_expired == other.include_expired &&
+      sec_type == other.sec_type  &&
+      multiplier == other.multiplier &&
+      strike == other.strike &&
+      right == other.right &&
+      multiplier == other.multiplier &&
+      expiry == other.expiry )
+
+    end
+
+
+    # returns the verified option for the next (regular) expiry of the contract.
+    #
+    # Argument: Reference date, provided as Date-Object or as parseable string or integer, i.e
+    #           Symbols::Options.rut.merge( strike: 2000 ).next_expiry( "2405")
+    #           returns   "<Option: RUT 20240516 put 2000.0 SMART USD>"  instead of
+    #                     "<Option: RUT 20240517 put 2000.0 SMART USD>"  because the third friday is a bank holiday
+    #
+    # Optionally a block can be provided, returning the expiry to check in the format "yyyymmdd"
+    #
+    # if verify is not available, the option is just returned.
+    #
+    # (always returns a new option, respects immutability of the IB::Contract)
+    #
+    # raises IB::LoadError if no Option is available for the expiry given. 
+    #
+    def next_expiry d =  Date.today
+      # get the next regular option
+      exp = block_given? ? yield : self.class.next_expiry( d )
+      # check if the option exists, otherwise fetch the previous date until a valid contract is detected
+      if IB::Connection.current.plugins.include? 'verify'
+        real_option =  nil
+        loop do
+          real_option = merge( expiry: exp ).verify.first
+          break unless real_option.nil?
+          exp =  ( exp.to_i - 1 ).to_s
+          error( "No suitable next expiry option found", :load ) if exp[-2..-1] == "00"
+        end
+        real_option
+      else
+        merge( expiry: exp, last_trading_day: Date.parse( exp ).strftime( "%Y-%m-%d" ) )
+      end
+
+    end
+
+    # returns the third friday of the (next) month  (class method)
+    #
+    # Argument: can either be Date, a String which parses to a Date or
+    #           an Integer, yymm yyyymm or yyyymmdd -->  2406 or 202406  or 20240618
+    #
+    #           if called with a digit, this is interpretated a day of the current month
+    #
+    def self.next_expiry  base =  Date.today
+
+      c =  0
+      begin
+      base_date = if base.is_a? Date
+                      [ base.year, base.month ]
+                  else
+                    (base = Date.parse(base.to_s)).then { | d | [ d.year,d.month ] }
+                  end.then{ |y,m| Date.new y,m }
+      rescue Date::Error => e
+        base =  base.to_s + "01"
+        c =  c + 1
+        retry if c == 1
+      end
+      error "Next-Expiry: Not a valid date: #{base}" if base_date.nil?
+        friday =  5
+        base_wday  =  base_date.wday
+        b= base_date + ( friday > base_wday ? friday - base_wday : 7 - base_wday + friday ) +  14
+
+        if b < base
+          next_expiry base.then{| y | a = y + 25; a.strftime "%Y%m01" }
+        else
+          b.strftime "%Y%m%d"
+        end
+      end
+
+    def to_human
+      "<Option: " + [symbol, expiry, right, strike, exchange, currency].join(" ") + ">"
+    end
+
+  end # class Option
+
+  class FutureOption   < Option
+    def default_attributes
+      super.merge :sec_type => :futures_option
+    end
+  end
+end # module IB

data/models/ib/option_detail.rb

@@ -0,0 +1,84 @@
+module IB
+  # Additional Option properties and Option-Calculations
+  class OptionDetail < Base
+    include BaseProperties
+
+    prop :delta,  :gamma, :vega, :theta, # greeks
+         :implied_volatility,
+   :pv_dividend, # anticipated Dividend
+   :under_price,  # price of the Underlying
+   :option_price,
+   :close_price,
+   :open_tick,
+   :bid_price,
+   :ask_price,
+   :prev_strike,
+   :next_strike,
+   :prev_expiry,
+   :next_expiry,
+   :option_price,
+   :updated_at
+    belongs_to :option
+
+    # returns true if all datafields are filled with reasonal data
+    def complete?
+     fields= [ :delta,  :gamma, :vega, :theta,
+         :implied_volatility, :pv_dividend, :open_tick,
+   :under_price, :option_price, :close_price, :bid_price, :ask_price]
+
+      !fields.detect{|y| self.send(y).nil?}
+
+    end
+
+    #  true if greeks are present
+    def greeks?   #  theta and implied volatility are not always present
+     fields= [ :delta,  :gamma, :vega ]
+
+      !fields.detect{|y| self.send(y).nil?}
+
+    end
+
+    # true if prices are received
+    def prices?
+      fields = [:implied_volatility, :under_price, :option_price]
+      !fields.detect{|y| self.send(y).nil?}
+    end
+
+    def iv
+      implied_volatility
+    end
+
+    def spread
+      bid_price - ask_price
+    end 
+
+    def to_human
+      outstr= ->( item ) { if item.nil? then "--" else  sprintf("%g" , item)  end  }
+      att = " optionPrice: #{ outstr[ option_price ]}, UnderlyingPrice: #{ outstr[ under_price] } impl.Vola: #{ outstr[ implied_volatility ]} ; dividend: #{ outstr[ pv_dividend ]}; "
+      greeks = "Greeks::  delta:  #{ outstr[ delta ] }; gamma: #{ outstr[ gamma ]}, vega: #{ outstr[ vega ] }; theta: #{ outstr[ theta ]}" 
+      prices= " close: #{ outstr[ close_price ]}; bid: #{ outstr[ bid_price ]}; ask: #{ outstr[ ask_price ]} "
+      if  complete?
+        "< "+ prices + "\n" + att + "\n" + greeks + " >"
+      elsif prices?
+        "< " + att + greeks + " >"
+      else
+  "< " + greeks + " >"
+      end
+
+    end
+
+    def table_header
+      [ 'Greeks', 'price',  'impl. vola', 'dividend', 'delta','gamma', 'vega' , 'theta']
+    end
+ 
+    def table_row
+      outstr= ->( item ) { { value: item.nil? ? "--" : sprintf("%g" , item) , alignment: :right } } 
+      outprice= ->( item ) { { value: item.nil? ? "--" : sprintf("%7.2f" , item) , alignment: :right } } 
+      option_short = ->{"#{option.right}  #{option.symbol}#{ "/"+ option.trading_class unless option.trading_class == option.symbol } #{option.expiry}  #{option.strike}"}
+      [ option_short[], outprice[ option_price ], outprice[ implied_volatility ],
+        outprice[ pv_dividend ], 
+        outprice[ delta ], outprice[ gamma ], outprice[ vega ] , outprice[ theta ] ]
+    end
+
+  end  # class
+end # module