ib-extensions 1.0

data/lib/ib/spread_prototypes/butterfly.rb

@@ -0,0 +1,79 @@
+module IB
+
+    module  Butterfly 
+      
+      extend SpreadPrototype
+			class << self
+
+				#  Fabricate a Butterfly from Scratch
+				#  -----------------------------------------
+				# 
+				#  
+				#
+				#   Call with 
+				#   IB::Butterfly.fabricate  IB::Option.new( symbol: :estx50, strike: 3000, expiry:'201901'), 
+				#														front: 2850, back: 3150
+				#
+				#   or
+				#   IB::Butterfly.build  from: Symbols::Index.stoxx
+				#                         strike: 3000
+			  #		 										  expiry: '201901', front: 2850, back: 3150
+				#
+				#		where :strike defines the center of the Spread.
+				def  fabricate master, front:, back:
+
+					error "fabrication is based on a master option. Please specify as first argument" unless master.is_a?(IB::Option)
+					strike = master.strike
+					master.right = :put unless master.right == :call
+					l=[] ; master.verify{|x| x.contract_detail= nil; l << x }
+#					puts "master:  #{master.attributes.inspect}"
+					if l.empty?
+						error "Invalid Parameters. No Contract found #{master.to_human}" 
+					elsif l.size > 1
+						error "ambigous contract-specification: #{l.map(&:to_human).join(';')}"
+						available_trading_classes = l.map( &:trading_class ).uniq
+						if available_trading_classes.size >1
+							error "Refine Specification with trading_class: #{available_trading_classes.join('; ')} "
+						else
+							error "Respecify expiry, verification reveals #{l.size} contracts  (only 1 is allowed)"
+						end
+					end
+
+					initialize_spread( master ) do | the_spread |
+						strikes = [front, master.strike, back]
+						strikes.zip([1, -2, 1]).each do |strike, ratio|
+							action = ratio >0 ?  :buy : :sell
+							leg =  IB::Option.new( master.attributes.merge( strike: strike )).verify!.essential
+							the_spread.add_leg  leg,  action: action,  ratio: ratio.abs 
+						end
+						the_spread.description =  the_description( the_spread )
+						the_spread.symbol = master.symbol
+					end
+				end
+
+				def  build from: , front:, back:,  **options
+					underlying_attributes =  { expiry: IB::Symbols::Futures.next_expiry, right: :put }.merge( from.attributes.slice( :symbol, :currency, :exchange, :strike )).merge( options )
+					puts underlying_attributes.inspect
+					fabricate  IB::Option.new( underlying_attributes), front: front, back: back
+				end
+
+				def the_description spread
+			x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:strike )].transpose
+			 "<Butterfly #{spread.symbol} #{spread.legs.first.right}(#{x.map{|w,strike| "#{w} :#{strike} "}.join( '|+|' )} )[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+				end
+
+				def defaults
+					super.merge expiry: IB::Symbols::Futures.next_expiry ,
+						          right: :put
+				end
+
+
+				def requirements
+					super.merge back: "the strike of the lower bougth option",
+											front: "the strike of the upper bougth option"
+
+				end
+
+			end # class
+		end	# module 
+end  # module ib

data/lib/ib/spread_prototypes/calendar.rb

@@ -0,0 +1,85 @@
+module IB
+
+    module  Calendar
+      
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Calendar-Spread from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is build by just changing the expiry
+#  The second leg is always SOLD !
+#
+#   Call with 
+#   IB::Calendar.fabricate  an_option, the_other_expiry
+			def fabricate master, the_other_expiry
+
+				error "Argument must be a IB::Future or IB::Option" unless  [:option, :future_option, :future ].include? master.sec_type
+
+				initialize_spread( master ) do | the_spread |
+					the_spread.add_leg master, action: :buy
+					
+					the_other_expiry =  the_other_expiry.values.first if the_other_expiry.is_a?(Hash)
+					back = the_spread.transform_distance master.expiry, the_other_expiry
+					the_spread.add_leg master.merge(expiry: back ), action: :sell
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+
+#  Build  Vertical out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strikes, :expiry, right
+#  
+#  Optional: :trading_class, :multiplier
+#
+#   Call with 
+#   IB::Calendar.build from: IB::Contract,	front: an_expiry,  back: an_expiry, 
+#																						right: {put or call}, strike: a_strike 
+			def build from:, **fields
+				underlying = if from.is_a?  IB::Option
+											 fields[:right] = from.right unless fields.key?(:right) 
+											 fields[:front] = from.expiry unless fields.key(:front)
+											 fields[:strike] = from.strike unless fields.key?(:strike)
+											 fields[:expiry] = from.expiry unless fields.key?(:expiry)
+											 fields[:trading_class] = from.trading_class unless fields.key?(:trading_class) || from.trading_class.empty?
+											 fields[:multiplier] = from.multiplier unless fields.key?(:multiplier) || from.multiplier.to_i.zero?
+											 details =  nil; from.verify{|c| details = c.contract_detail }
+											 IB::Contract.new( con_id: details.under_con_id, 
+																				currency: from.currency)
+																			 .verify!
+																			 .essential
+										 else
+											 from
+										 end
+				kind = { :front => fields.delete(:front), :back => fields.delete(:back) }
+				error "Specifiaction of :front and :back expiries nessesary, got: #{kind.inspect}" if kind.values.any?(nil)
+				initialize_spread( underlying ) do | the_spread |
+					leg_prototype  = IB::Option.new underlying.attributes
+															.slice( :currency, :symbol, :exchange)
+															.merge(defaults)
+															.merge( fields )
+					kind[:back] = the_spread.transform_distance kind[:front], kind[:back]
+					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+					the_spread.add_leg IB::Contract.build( leg_prototype.attributes.merge(expiry: kind[:front] )), action: :buy
+					the_spread.add_leg IB::Contract.build( leg_prototype.attributes.merge(expiry: kind[:back])), action: :sell
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+      def defaults
+      super.merge expiry: IB::Symbols::Futures.next_expiry, 
+									right: :put
+      end
+
+
+			def the_description spread
+			x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:last_trading_day )].transpose
+			 "<Calendar #{spread.symbol} #{spread.legs.first.right}(#{spread.legs.first.strike})[#{x.map{|w,l_t_d| "#{w} :#{Date.parse(l_t_d).strftime("%b %Y")} "}.join( '|+|' )} >"
+			end
+		 end # class
+    end	# module vertical
+end  # module ib

data/lib/ib/spread_prototypes/stock-spread.rb

@@ -0,0 +1,48 @@
+module IB
+
+    module   StockSpread
+      
+      extend SpreadPrototype
+			class << self
+
+				#  Fabricate a StockSpread from Scratch
+				#  -----------------------------------------
+				# 
+				#  
+				#
+				#   Call with 
+				#   IB::StockSpread.fabricate  'GE','F', ratio:[1,-2]
+				#
+				#   or
+				#   IB::StockSpread.fabricate  IB::Stock.new(symbol:'GE'), 'F', ratio:[1,-2]
+				#
+				def  fabricate *underlying,  ratio: [1,-1], **args
+					#
+					are_stocks =  ->(l){ l.all?{|y| y.is_a? IB::Stock} }
+					legs = underlying.map{|y| y.is_a?( IB::Stock ) ? y.merge(args) : IB::Stock.new( symbol: y ).merge(args)}
+					error "only spreads with two underyings of type »IB::Stock« are supported" unless legs.size==2 && are_stocks[legs]
+					initialize_spread( legs.first ) do | the_spread |
+						c_l = legs.zip(ratio).map do |l,r| 
+						action = r >0 ?  :buy : :sell
+						the_spread.add_leg  l,  action: action,  ratio: r.abs 
+					end
+					the_spread.description =  the_description( the_spread )
+					the_spread.symbol = legs.map( &:symbol ).sort.join(",")  # alphabetical order
+
+					end
+				end
+
+				def the_description spread
+					info=  spread.legs.map( &:symbol ).zip(spread.combo_legs.map( &:weight ))
+					"<StockSpread #{info.map{|c| c.join(":")}.join(" , ")} (#{spread.currency} )>"
+
+				end
+
+				# always route a order as NonGuaranteed 
+				def order_requirements
+					{	combo_params:  ['NonGuaranteed', true] }
+				end
+
+			end # class
+		end	# module 
+end  # module ib

data/lib/ib/spread_prototypes/straddle.rb

@@ -0,0 +1,75 @@
+module IB
+
+    module  Straddle
+      
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Straddle from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is simply build by flipping the right
+#
+#   Call with 
+#   IB::Spread::Straddle.fabricate an_option
+			def fabricate master
+
+				flip_right = ->(the_right){  the_right == :put ? :call : :put   }
+				error "Argument must be a IB::Option" unless [ :option, :futures_option ].include?( master.sec_type )
+
+
+				initialize_spread( master ) do | the_spread |
+					the_spread.add_leg master.essential
+					the_spread.add_leg( master.essential.merge( right: flip_right[master.right], local_symbol: "") )
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+
+#  Build  Straddle out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strike, :expiry 
+#  
+#  Optional: :trading_class, :multiplier
+#
+#   Call with 
+#   IB::Spread::Straddle.build from: IB::Contract, strike: a_value, expiry: yyyymmm(dd) 
+			def build from:, ** fields
+				if  from.is_a?  IB::Option
+					fabricate from.merge(fields)
+				else
+					initialize_spread( from ) do | the_spread |
+						leg_prototype  = IB::Option.new from.attributes
+						.slice( :currency, :symbol, :exchange)
+						.merge(defaults)
+						.merge( fields )
+
+						leg_prototype.sec_type = 'FOP' if from.is_a?(IB::Future)
+						the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :put )
+						the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :call )
+						error "Initialisation of Legs failed" if the_spread.legs.size != 2
+						the_spread.description =  the_description( the_spread )
+					end
+				end
+			end
+
+      def defaults
+      super.merge expiry: IB::Symbols::Futures.next_expiry 
+      end
+
+
+      def requirements
+				super.merge strike: "the strike of both options",
+									  expiry: "Expiry expressed as »yyyymm(dd)« (String or Integer) )"
+      end
+
+
+			def the_description spread
+			 "<Straddle #{spread.symbol}(#{spread.legs.first.strike})[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+			end
+
+
+      end # class
+    end	# module combo
+end  # module ib

data/lib/ib/spread_prototypes/strangle.rb

@@ -0,0 +1,96 @@
+module IB
+
+    module  Strangle
+      
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Strangle from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is build by flipping the right and adjusting the strike by distance
+#
+#   Call with 
+#   IB::Strangle.fabricate an_option, numeric_value 
+			def fabricate master, distance
+
+				flip_right = ->(the_right){  the_right == :put ? :call : :put   }
+
+				error "Argument must be an option" unless [:option, :futures_option].include? master.sec_type
+
+
+				initialize_spread( master ) do | the_spread |
+					the_spread.add_leg master
+					the_spread.add_leg( master
+														 .essential
+														 .merge( right: flip_right[master.right],
+																		 strike: master.strike.to_f + distance.to_f ,
+																	   local_symbol: '',
+																	   con_id: 0 ) )
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+
+#  Build  Strangle out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strike, :expiry 
+#  
+#  Optional: :trading_class, :multiplier
+#
+#   Call with 
+#   IB::Strangle.build from: IB::Contract, p:  a_value,  c:  a_value, expiry: yyyymm(dd) 
+			def build from:, **fields
+				underlying = if from.is_a?  IB::Option
+											 fields[:p] = from.strike unless fields.key?(:p) || from.right == :call
+											 fields[:c] = from.strike unless fields.key?(:c) || from.right == :puta
+											 fields[:expiry] = from.expiry unless fields.key?(:expiry)
+											 fields[:trading_class] = from.trading_class unless fields.key?(:trading_class) || from.trading_class.empty?
+											 fields[:multiplier] = from.multiplier unless fields.key?(:multiplier) || from.multiplier.to_i.zero?
+
+											 details =  from.verify.first.contract_detail 
+											 IB::Contract.new( con_id: details.under_con_id, 
+																				currency: from.currency, 
+																			  exchange: from.exchange)
+																			 .verify.first
+																			 .essential
+										 else
+											 from
+										 end
+				kind = { :p => fields.delete(:p), :c => fields.delete(:c) }
+				initialize_spread( underlying ) do | the_spread |
+					leg_prototype  = IB::Option.new underlying.attributes
+															.slice( :currency, :symbol, :exchange)
+															.merge(defaults)
+															.merge( fields )
+															.merge( local_symbol: "" )
+															
+					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+					the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :put, strike: kind[:p] )
+					the_spread.add_leg IB::Contract.build leg_prototype.attributes.merge( right: :call, strike: kind[:c] )
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+      def defaults
+      super.merge expiry: IB::Symbols::Futures.next_expiry 
+      end
+
+
+      def requirements
+				super.merge p: "the strike of the put option",
+										c: "the strike of the call option",
+									  expiry: "Expiry expressed as »yyyymm(dd)« (String or Integer) )"
+      end
+
+
+
+			def the_description spread
+			 "<Strangle #{spread.symbol}(#{spread.legs.map(&:strike).join(",")})[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+			end
+
+      end # class
+    end	# module combo
+end  # module ib

data/lib/ib/spread_prototypes/vertical.rb

@@ -0,0 +1,84 @@
+module IB
+
+    module  Vertical
+      
+      extend SpreadPrototype
+      class << self
+
+
+#  Fabricate a Vertical from a Master-Option
+#  -----------------------------------------
+#  If one Leg is known, the other is build by flipping the right and adjusting the strike by distance
+#
+#   Call with 
+#   IB::Vertical.fabricate  an_option, buy: {another_strike},  (or) , :sell{another_strike} 
+			def fabricate master, buy: 0, sell: 0
+
+				error "Argument must be an option" unless [:option, :futures_option].include? master.sec_type
+				error "Unable to fabricate Vertical. Either :buy or :sell must be specified " if buy.zero? && sell.zero?
+
+				buy =  master.strike if buy.zero? 
+				sell =  master.strike if sell.zero? 
+				initialize_spread( master ) do | the_spread |
+					the_spread.add_leg master.essential.merge(strike: sell, local_symbol: "", con_id: 0), action: :sell
+					the_spread.add_leg master.essential.merge(strike: buy, local_symbol: "", con_id: 0), action: :buy
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+
+#  Build  Vertical out of an Underlying
+#  -----------------------------------------
+#  Needed attributes: :strikes, :expiry, right
+#  
+#  Optional: :trading_class, :multiplier
+#
+#   Call with 
+#   IB::Straddle.build from: IB::Contract, buy: a_strike,  sell: a_stike, right: {put or call}, expiry: yyyymmm(dd) 
+			def build from:, **fields
+				underlying = if from.is_a?  IB::Option
+											 fields[:right] = from.right unless fields.key?(:right) 
+											 fields[:sell] = from.strike unless fields.key(:sell)
+											 fields[:buy] = from.strike unless fields.key?(:buy)
+											 fields[:expiry] = from.expiry unless fields.key?(:expiry)
+											 fields[:trading_class] = from.trading_class unless fields.key?(:trading_class) || from.trading_class.empty?
+											 fields[:multiplier] = from.multiplier unless fields.key?(:multiplier) || from.multiplier.to_i.zero?
+											 details =  from.verify.first.contract_detail 
+											 IB::Contract.new( con_id: details.under_con_id, 
+																				currency: from.currency, 
+																			  exchange: from.exchange)
+																			 .verify.first
+																			 .essential
+										 else
+											 from
+										 end
+				kind = { :buy => fields.delete(:buy), :sell => fields.delete(:sell) }
+				error "Specifiaction of :buy and :sell nessesary, got: #{kind.inspect}" if kind.values.any?(nil)
+				initialize_spread( underlying ) do | the_spread |
+					leg_prototype  = IB::Option.new underlying.attributes
+															.slice( :currency, :symbol, :exchange)
+															.merge(defaults)
+															.merge( fields )
+															.merge( local_symbol: "" )
+					leg_prototype.sec_type = 'FOP' if underlying.is_a?(IB::Future)
+					the_spread.add_leg  leg_prototype.merge(strike: kind[:sell]), action: :sell
+					the_spread.add_leg  leg_prototype.merge(strike: kind[:buy] ), action: :buy
+					error "Initialisation of Legs failed" if the_spread.legs.size != 2
+					the_spread.description =  the_description( the_spread )
+				end
+			end
+
+      def defaults
+      super.merge expiry: IB::Symbols::Futures.next_expiry, 
+									right: :put
+      end
+
+
+			def the_description spread
+				x= [ spread.combo_legs.map(&:weight) , spread.legs.map( &:strike )].transpose
+				"<Vertical #{spread.symbol} #{spread.legs.first.right}(#{x.map{|w,strike| "#{w} :#{strike} "}.join( '|+|' )} )[#{Date.parse(spread.legs.first.last_trading_day).strftime("%b %Y")}]>"
+			end
+		 end # class
+    end	# module vertical
+end  # module ib