ib-extensions 1.0

data/lib/ib/models/spread.rb

@@ -0,0 +1,159 @@
+require 'ib/verify'
+module IB
+	class Spread  < Bag
+		has_many :legs
+
+		using IBSupport
+
+=begin
+Parameters:   front: YYYMM(DD)
+							back: {n}w, {n}d or YYYYMM(DD)
+
+Adds (or substracts) relative (back) measures to the front month, just passes absolute YYYYMM(DD) value
+	
+	front: 201809   back:  2m (-1m) --> 201811 (201808)
+	front: 20180908 back:  1w (-1w) --> 20180918 (20180902)
+=end
+
+		def transform_distance front, back
+			# Check Format of back: 201809 --> > 200.000
+			#	                      20180989 ---> 20.000.000
+			start_date = front.to_i < 20000000 ?  Date.strptime(front.to_s,"%Y%m") :  Date.strptime(front.to_s,"%Y%m%d") 
+			nb = if back.to_i > 200000 
+						 back.to_i
+					 elsif back[-1] == "w" && front.to_i > 20000000
+						 start_date + (back.to_i * 7)
+					 elsif back[-1] == "m" && front.to_i > 200000
+						 start_date >> back.to_i
+					 else
+						 error "Wrong date #{back} required format YYYMM, YYYYMMDD ord {n}w or {n}m"
+					 end
+			if nb.is_a?(Date)	
+				if back[-1]=='w'
+					nb.strftime("%Y%m%d")
+				else
+					nb.strftime("%Y%m")
+				end
+			else
+				nb
+			end 
+		end # def 
+	
+		def to_human
+			self.description
+		end
+
+		def calculate_spread_value( array_of_portfolio_values )
+			array_of_portfolio_values.map{|x| x.send yield }.sum if block_given?
+		end
+	
+		def fake_portfolio_position(  array_of_portfolio_values )
+				calculate_spread_value= ->( a_o_p_v, attribute ) do
+							a_o_p_v.map{|x| x.send attribute }.sum 
+				end
+				ar=array_of_portfolio_values
+				IB::PortfolioValue.new  contract: self, 
+					average_cost: 	calculate_spread_value[ar, :average_cost],
+					market_price: 	calculate_spread_value[ar, :market_price],
+					market_value: 	calculate_spread_value[ar, :market_value],
+					unrealized_pnl: 	calculate_spread_value[ar, :unrealized_pnl],
+					realized_pnl: 	calculate_spread_value[ar, :realized_pnl],
+					position: 0
+
+		end
+
+
+
+		def serialize_rabbit
+			{ "Spread" => serialize( :option, :trading_class ),
+				'legs' => legs.map{ |y| y.serialize :option, :trading_class }, 'combo_legs' => combo_legs.map(&:serialize),
+				'misc' => [description]
+			}	
+		end
+
+		# adds a leg to any spread
+		#
+		# Parameter: 
+		#		contract:  Will be verified. Contract.essential is added to legs-array
+		#		action: :buy or :sell
+		#		weight:
+		#		ratio:
+		#		
+		#	Default:  action: :buy, 	weight: 1
+
+		def add_leg contract,  **leg_params
+			evaluated_contracts =  []
+			nc =	contract.verify.first.essential
+			#			weigth = 1 --> sets Combo.side to buy and overwrites the action statement
+#			leg_params[:weight] = 1 unless leg_params.key?(:weight) || leg_params.key?(:ratio)
+			if nc.is_a?( IB::Contract) && nc.con_id.present?
+					the_leg= ComboLeg.new( nc.attributes.slice( :con_id, :exchange )
+																					.merge( leg_params ))
+					self.combo_legs << the_leg 
+					self.description = description + " added #{nc.to_human}" rescue "Spread: #{nc.to_human}"
+					self.legs << nc
+			end
+			self  # return value to enable chaining
+
+
+		end
+
+		# removes the contract from the spread definition
+		#
+		def remove_leg contract
+			contract.verify do |c|
+				legs.delete_if { |x| x.con_id == c.con_id }
+				combo_legs.delete_if { |x| x.con_id == c.con_id }
+				self.description = description + " removed #{c.to_human}"
+			end
+			self
+		end
+
+
+		def essential
+				legs.each{ |x| x.essential }
+				self
+		end
+		def  multiplier
+			(legs.map(&:multiplier).sum/legs.size).to_i
+		end
+		
+		# provide a negative con_id 
+		def con_id
+			-legs.map(&:con_id).sum
+		end
+
+
+		def non_guaranteed= x
+      super.merge		combo_params: [ ['NonGuaranteed', x] ]
+		end
+
+
+		def non_guaranteed
+     	combo_params['NonGuaranteed']
+		end
+#  optional: specify default order prarmeters for all spreads
+#		def order_requirements
+#		 super.merge		symbol: symbol
+#		end
+
+
+		def self.build_from_json container
+			read_leg = ->(a) do 
+				  IB::ComboLeg.new :con_id => a.read_int,
+                           :ratio => a.read_int,
+                           :action => a.read_string,
+                           :exchange => a.read_string
+
+			end
+			object= self.new  container['Spread'].read_contract
+			object.legs = container['legs'].map{|x| IB::Contract.build x.read_contract}
+			object.combo_legs = container['combo_legs'].map{ |x| read_leg[ x ] } 
+			object.description = container['misc'].read_string
+			object
+
+		end
+	end
+
+
+end

data/lib/ib/option-chain.rb

@@ -0,0 +1,198 @@
+require 'ib/verify'
+require 'ib/market-price'
+module IB
+# define a custom ErrorClass which can be fired if a verification fails
+class VerifyError < StandardError
+end
+
+class Contract 
+
+
+	
+# returns the Option Chain of the contract (if available)
+#
+## parameters
+### right:: :call, :put, :straddle
+### ref_price::  :request or a numeric value
+### sort:: :strike, :expiry 
+### exchange:: List of Exchanges to be queried (Blank for all available Exchanges)
+		def option_chain ref_price: :request, right: :put, sort: :strike, exchange: ''
+
+			ib =  Connection.current
+
+			## Enable Cashing of Definition-Matrix
+			@option_chain_definition ||= [] 
+
+			my_req = nil; finalize= false
+			
+			# -----------------------------------------------------------------------------------------------------
+			# get OptionChainDefinition from IB ( instantiate cashed Hash )
+			if @option_chain_definition.blank?
+				sub_sdop = ib.subscribe( :SecurityDefinitionOptionParameterEnd ) { |msg| finalize = 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 = true
+						end
+						if @option_chain_definition.blank? &&  message[:trading_class] == symbol 
+							@option_chain_definition =  msg.data
+						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]
+
+				Thread.new do  
+
+					Timeout::timeout(1, IB::TransmissionError,"OptionChainDefinition not received" ) do
+						loop{ sleep 0.1; break if finalize } 
+					end
+					ib.unsubscribe sub_sdop , sub_ocd
+				end.join
+		else
+			Connection.logger.error { "#{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.error{  "#{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 )
+				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
+			option_chain(  right: right, ref_price: ref_price, sort: :expiry) do | chain |
+								chain[0]
+			end
+
+				
+			end
+
+		# return   InTheMoneyOptions
+		def itm_options count:  5, right: :put, ref_price: :request, sort: :strike
+			option_chain(  right: right,  ref_price: ref_price, sort: sort ) 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
+			option_chain( right: right, ref_price: ref_price, sort: sort ) 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
+
+
+		def associate_ticdata
+
+			tws=  IB::Connection.current 		 # get the initialized ib-ruby instance
+			the_id =  nil
+			finalize= false
+			#  switch to delayed data
+			tws.send_message :RequestMarketDataType, :market_data_type => :delayed
+
+			s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	finalize = true	if msg.ticker_id == the_id }
+
+			sub_id = tws.subscribe(:TickPrice, :TickSize,  :TickGeneric, :TickOption) do |msg|
+				self.bars << msg.the_data 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 
+
+			#keep the method-call running until the request finished
+			#and cancel subscriptions to the message handler.
+			Thread.new do 
+				i=0; loop{ i+=1; sleep 0.1; break if finalize || i > 1000 }
+				tws.unsubscribe sub_id 
+				tws.unsubscribe s_id
+				#puts "#{symbol} data gathered" 
+			end  # method returns the (running) thread
+
+		end # def 
+end # class
+
+
+
+
+end # module

data/lib/ib/option-greeks.rb

@@ -0,0 +1,88 @@
+module IB
+
+
+	
+ class Option
+# 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
+
+		 #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
+			 finalize= false
+			 # subscribe to TickPrices
+			 s_id = tws.subscribe(:TickSnapshotEnd) { |msg|	finalize = true	if msg.ticker_id == the_id }
+			 e_id = tws.subscribe(:Alert){|x|  finalize = true if [200,353].include?( x.code) && x.error_id == the_id } 
+			 # 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
+					 tickdata =  tickdata &.first unless [:bidask, :all].include? what
+					 finalize = 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
+			 the_id = tws.send_message :RequestMarketData,  contract: self , snapshot: true 
+
+			 begin
+				 # todo implement config-feature to set timeout in configuration   (DRY-Feature)
+				 Timeout::timeout(5) do   # max 5 sec.
+					 loop{ break if finalize ; sleep 0.05 } 
+					 # reduce :close_price delayed_close  to close a.s.o 
+					 self.misc =  tickdata if thread  # store internally if in thread modus
+				 end
+			 rescue Timeout::Error
+				 Connection.logger.info{ "#{to_human} --> No Marketdata received " }
+			 end
+			 tws.unsubscribe sub_id, s_id, e_id
+		 end  # thread
+		 if thread
+			 th		# return thread
+		 else
+			 th.join
+			 tickdata	# return 
+		 end
+	 end #
+
+ end
+end

data/lib/ib/order-prototypes.rb

@@ -0,0 +1,110 @@
+# These modules are used to facilitate referencing of most common Ordertypes
+
+module IB
+	module OrderPrototype
+
+
+#The Module OrderPrototypes provides a wrapper to define even complex ordertypes.
+#
+#The Order is build by 
+#
+#	IB::<OrderPrototye>.order
+#
+#A description is available through
+#
+#	puts IB::<OrderPrototype>.summary
+#
+#Nessesary and optional arguments are printed by
+#
+#	puts IB::<OrderPrototype>.parameters
+#
+#Orders can be setup interactively
+#
+#		> d =  Discretionary.order
+#		Traceback (most recent call last): (..)
+#		IB::ArgumentError (IB::Discretionary.order -> A necessary field is missing: 
+#					action: --> {"B"=>:buy, "S"=>:sell, "T"=>:short, "X"=>:short_exempt})
+#		> d =  Discretionary.order action: :buy
+#		IB::ArgumentError (IB::Discretionary.order -> A necessary field is missing: 
+#					total_quantity: --> also aliased as :size)
+#		> d =  Discretionary.order action: :buy, size: 100
+#					Traceback (most recent call last):
+#		IB::ArgumentError (IB::Discretionary.order -> A necessary field is missing: limit_price: --> decimal)
+#
+#
+#
+#Prototypes are defined as module. They extend OrderPrototype and establish singleton methods, which
+#can adress and extend similar methods from OrderPrototype. 
+#
+#
+
+
+
+		def order **fields
+
+			# special treatment of size:  positive numbers --> buy order, negative: sell 
+			if fields[:size].present? && fields[:action].blank?
+				error "Size = 0 is not possible" if fields[:size].zero?
+				fields[:action] = fields[:size] >0 ? :buy  : :sell
+				fields[:size] = fields[:size].abs
+			end
+			# change aliases  to the original. We are modifying the fields-hash.
+			fields.keys.each{|x| fields[aliases.key(x)] = fields.delete(x) if aliases.has_value?(x)}
+			# inlcude defaults (arguments override defaults)
+			the_arguments = defaults.merge fields
+			# check if requirements are fullfilled
+			necessary = requirements.keys.detect{|y| the_arguments[y].nil?}
+			if necessary.present?
+				msg =self.name + ".order -> A necessary field is missing: #{necessary}: --> #{requirements[necessary]}"
+				error msg, :args, nil
+			end
+			if alternative_parameters.present?
+				unless ( alternative_parameters.keys  & the_arguments.keys ).size == 1
+					msg =self.name + ".order -> One of the alternative fields needs to be specified: \n\t:" +
+						"#{alternative_parameters.map{|x| x.join ' => '}.join(" or \n\t:")}"
+					error msg, :args, nil
+				end
+			end
+
+			# initialise order with given attributes	
+			IB::Order.new the_arguments
+		end
+
+		def alternative_parameters
+			{}
+		end
+		def requirements
+			{ action: IB::VALUES[:side], total_quantity: 'also aliased as :size' }
+		end
+
+		def defaults
+			{  tif: :good_till_cancelled }
+		end
+
+		def optional
+			{ account: 'Account(number) to trade on' }
+		end
+
+		def aliases
+			{  total_quantity: :size }
+		end
+
+		def parameters
+			the_output = ->(var){ var.map{|x| x.join(" --> ") }.join("\n\t: ")}
+
+			"Required : " + the_output[requirements] + "\n --------------- \n" +
+				"Optional : " + the_output[optional] + "\n --------------- \n" 
+
+		end
+
+	end
+end
+
+require 'ib/order_prototypes/forex'
+require 'ib/order_prototypes/market'
+require 'ib/order_prototypes/limit'
+require 'ib/order_prototypes/stop'
+require 'ib/order_prototypes/volatility'
+require 'ib/order_prototypes/premarket'
+require 'ib/order_prototypes/pegged'
+require 'ib/order_prototypes/combo'