ib-symbols 1.0

data/lib/ib/symbols/forex.rb

@@ -0,0 +1,41 @@
+module IB
+  module Symbols
+    module Forex
+      extend Symbols
+
+      def self.contracts
+        @contracts ||= define_contracts
+      end
+
+      private
+
+      # IDEALPRO is for orders over 20,000 and routes to the interbank quote stream.
+      # IDEAL is for smaller orders, and has wider spreads/slower execution... generally
+      # used for smaller currency conversions. IB::Symbols::Forex contracts are pre-defined
+      # on IDEALPRO, if you need something else please define forex contracts manually.
+      def self.define_contracts
+        @contracts = {}
+
+        # use combinations of these currencies for pre-defined forex contracts
+        currencies = [ "aud", "cad", "chf", "eur", "gbp", "hkd", "jpy", "nzd", "usd" ]
+
+        # create pairs list from currency list
+        pairs = currencies.product(currencies).
+          map { |pair| pair.join.upcase unless pair.first == pair.last }.compact
+
+        # now define each contract
+        pairs.each do |pair|
+          @contracts[pair.downcase.to_sym] = IB::Forex.new(
+            :symbol => pair[0..2],
+            :exchange => "IDEALPRO",
+            :currency => pair[3..5],
+						:local_symbol => pair[0..2]+'.'+pair[3..5],
+            :description => pair
+          )
+        end
+        
+        @contracts
+      end
+    end
+  end
+end

data/lib/ib/symbols/futures.rb

@@ -0,0 +1,137 @@
+# The Futures module tries to guess the front month future using a crude algorithm that
+# does not take into account expiry/rollover day. This will be valid most of the time,
+# but near/after expiry day the next quarter's contract takes over as the volume leader.
+
+module IB
+  module Symbols
+    module Futures
+      extend Symbols
+
+      # Find the next front month of quarterly futures.
+      # N.B. This will not work as expected during the front month before expiration, as
+      # it will point to the next quarter even though the current month is still valid!
+      def self.next_quarter_month time=Time.now
+        [3, 6, 9, 12].find { |month| month > time.month } || 3 # for December, next March
+      end
+
+      def self.next_quarter_year time=Time.now
+        next_quarter_month(time) < time.month ? time.year + 1 : time.year
+      end
+
+      # WARNING: This is currently broken. It returns the next
+      # quarterly expiration month after the current month. Many futures
+      # instruments have monthly contracts for the near months. This
+      # method will not work for such contracts; it will return the next
+      # quarter after the current month, even though the present month
+      # has the majority of the trading volume.
+      #
+      # For example, in early November of 2011, many contracts have the
+      # vast majority of their volume in the Nov 2011 contract, but this
+      # method will return the Dec 2011 contract instead.
+      #
+      def self.next_expiry time=Time.now
+        "#{ next_quarter_year(time) }#{ sprintf("%02d", next_quarter_month(time)) }"
+      end
+
+      # Convenience method; generates an IB::Future instance for a futures
+      # contract with the given parameters.
+      #
+      # If expiry is nil, it will use the end month of the current
+      # quarter. This will be wrong for most contracts most of the time,
+      # since most contracts have the majority of their volume in a
+      # nearby intraquarter month.
+      #
+      # It is recommended that you specify an expiration date manually
+      # until next_expiry is fixed. Expiry should be a string in the
+      # format "YYYYMM", where YYYY is the 4 digit year and MM is the 2
+      # digit month. For example, November 2011 is "201111".
+      #
+      def self.future(base_symbol, exchange, currency, description="", expiry=nil)
+        IB::Future.new :symbol => base_symbol,
+          :expiry => expiry || next_expiry,
+          :exchange => exchange,
+          :currency => currency,
+          :sec_type => SECURITY_TYPES[:future],
+          :description => description
+      end
+
+      def self.contracts
+	@contracts.presence ||( super.merge  :ym => IB::Future.new(:symbol => "YM",
+                                  :expiry => next_expiry,
+                                  :exchange => "ECBOT",
+                                  :currency => "USD",
+                                  :description => "Mini-DJIA future"),
+         :nq => IB::Future.new(:symbol => "NQ",
+                                  :expiry => next_expiry,
+                                  :exchange => "GLOBEX",
+                                  :currency => "USD",
+                                  :multiplier => 20,
+                                  :description => "E-Mini Nasdaq 100 future"),
+         :es => IB::Future.new(:symbol => "ES",
+                                  :expiry => next_expiry,
+                                  :exchange => "GLOBEX",
+                                  :currency => "USD",
+                                  :multiplier => 50,
+                                  :description => "E-Mini S&P 500 future"),
+			:zn => IB::Future.new( symbol: 'ZN',
+														expiry: next_expiry,
+													  currency: 'USD',
+													  multiplier: 1000,
+													  exchange: 'ECBOT',
+														description: 'US Treasury Note -- 10 Years'),
+			:zb => IB::Future.new( symbol: 'ZB',
+														expiry: next_expiry,
+													  currency: 'USD',
+													  multiplier: 1000,
+													  exchange: 'ECBOT',
+														description: 'US Treasury Note -- 30 Years'),
+				:mini_dax => IB::Future.new( symbol: 'DAX', exchange: 'DTB', 
+																	expiry:  next_expiry,
+																	currency: 'EUR',
+																	multiplier: 5,
+																	description: 'Mini DAX-Future'),
+			#	:dax => IB::Future.new( symbol: 'DAX', exchange: 'DTB', 
+			#														expiry:  next_expiry,
+			#														currency: 'EUR',
+			#														multiplier: 25,
+		#															description: 'DAX-Future'),
+				:stoxx=> IB::Future.new( symbol: 'ESTX50', exchange: 'DTB', 
+																	expiry:  next_expiry,
+																	currency: 'EUR',
+																	multiplier: 10,
+																	description: 'EuroStoxx 50 -Future'),
+        :gbp => IB::Future.new(:symbol => "GBP",
+                                 :expiry => next_expiry,
+                                 :exchange => "GLOBEX",
+                                 :currency => "USD",
+                                 :multiplier => 62500,
+                                 :description => "British Pounds future"),
+         :eur => IB::Future.new(:symbol => "EUR",
+                                  :expiry => next_expiry,
+                                  :exchange => "GLOBEX",
+                                  :currency => "USD",
+                                  :multiplier => 12500,
+                                  :description => "Euro FX future"),
+         :jpy => IB::Future.new(:symbol => "JPY",
+                                  :expiry => next_expiry,
+                                  :exchange => "GLOBEX",
+                                  :currency => "USD",
+                                  :multiplier => 12500000,
+                                  :description => "Japanese Yen future"),
+         :hsi => IB::Future.new(:symbol => "HSI",
+                                  :expiry => next_expiry,
+                                  :exchange => "HKFE",
+                                  :currency => "HKD",
+                                  :multiplier => 50,
+                                  :description => "Hang Seng Index future"),
+         :vix => IB::Future.new(:symbol => "VIX",
+                                  :expiry => next_expiry,
+                                  :exchange => "CFE", #"ECBOT",
+                                  :currency => "USD",
+                                  :description => "CBOE Volatility Index future"))
+	
+        
+      end
+    end
+  end
+end

data/lib/ib/symbols/index.rb

@@ -0,0 +1,43 @@
+# Frequently used stock contracts definitions
+module IB
+  module Symbols
+    module Index
+      extend Symbols
+
+      def self.contracts
+	   @contracts.presence ||  super.merge( 
+		     :dax => IB::Index.new(:symbol => "DAX", :currency => "EUR", exchange: 'DTB',
+                                    :description => "DAX Performance Index."),
+				 :asx => IB::Index.new( :symbol  => 'AP', :currency => 'AUD', exchange: 'ASX',
+																		:description => "ASX 200 Index" ),
+				 :hsi => IB::Index.new( :symbol  => 'HSI', :currency => 'HKD', exchange: 'HKFE',
+																		:description => "Hang Seng Index" ),
+				 :minihsi => IB::Index.new( :symbol  => 'MHI', :currency => 'HKD', exchange: 'HKFE',
+																		:description => "Mini Hang Seng Index" ),
+		     :stoxx => IB::Index.new(:symbol => "ESTX50", :currency => "EUR", exchange: 'DTB',
+                                    :description => "Dow Jones Euro STOXX50"),
+		     :spx => IB::Index.new(:symbol => "SPX", :currency => "USD", exchange: 'CBOE',
+                                    :description => "Dow Jones Euro STOXX50"),
+				 :vhsi =>  IB::Index.new( symbol: 'VHSI', exchange: 'HKFE',
+																		:description => "Hang Seng Volatility Index"),
+				 :vasx  =>  IB::Index.new( symbol: 'XVI',   exchange: 'ASX',
+																		:description => "ASX 200 Volatility Index")	, 													
+		     :vstoxx => IB::Index.new(:symbol => "V2TX", :currency => "EUR", exchange: 'DTB',
+                                    :description => "VSTOXX Volatility Index"),
+		     :vdax => IB::Index.new(:symbol => "VDAX", exchange: 'DTB',
+                                    :description => "German VDAX Volatility Index"),
+		     :vix => IB::Index.new(:symbol => "VIX", exchange: 'CBOE',
+                                    :description => "CBOE Volatility Index"),
+				:volume => IB::Index.new( symbol: 'VOL-NYSE', exchange: 'NYSE',
+																	 description: "NYSE Volume Index" ),
+				:trin => IB::Index.new( symbol: 'TRIN-NYSE', exchange: 'NYSE',
+																   description: "NYSE TRIN (or arms) Index"),
+				:tick => IB::Index.new( symbol: 'TICK-NYSE', exchange: 'NYSE',
+																   description: "NYSE TICK Index"),
+				:a_d => IB::Index.new( symbol: 'AD-NYSE', exchange: 'NYSE',
+																	 description: "NYSE Advance Decline Index")	      )
+      end
+
+    end
+  end
+end

data/lib/ib/symbols/options.rb

@@ -0,0 +1,82 @@
+# Option contracts definitions.
+# TODO: add next_expiry and other convenience from Futures module.
+# Notice:  OSI-Notation is broken
+module IB
+  module Symbols
+    module Options
+      extend Symbols
+
+
+			## usage:  IB::Symbols::Options.stoxx.merge( strike: 3300 )
+      def self.contracts
+        @contracts ||= {
+					stoxx:  IB::Option.new(  symbol: :ESTX50, strike: 3000, 
+																			  expiry: IB::Symbols::Futures.next_expiry , 
+																				right: :put, 
+																				trading_class: 'OESX', 
+																				currency: 'EUR', exchange: 'DTB',
+																		 description: "ESTX50 Put Option quarterly"),
+					:ge => IB::Option.new(:symbol => "GE",
+																	:expiry =>  IB::Symbols::Futures.next_expiry, 
+																	:right => "CALL",
+																	:strike => 7,
+																	:multiplier => 100,
+																	:exchange => 'SMART',
+																	:currency => 'USD',
+																	:description => "General Electric 7 Call"),
+					:aapl => IB::Option.new(:symbol => "AAPL", exchange: 'SMART',
+																		 :expiry => IB::Symbols::Futures.next_expiry, 
+																		 :right => "C",
+																		 :strike => 130,
+																		 :currency => 'USD',
+																		 :description => "Apple Call 130"),
+          :z750 => IB::Option.new(:symbol => "Z",
+                                 :exchange => "ICEEU",
+                                 :expiry => "201903",
+                                 :right => "CALL",
+                                 :strike => 7000.0,
+																 :description => " FTSE-100 index 750 Call 2019-03"),
+			:ibm_lazy_expiry => IB::Option.new( symbol: 'IBM', right: :put, strike: 140, exchange: 'SMART',
+																				 description: 'IBM-Option Chain with strike 140'),
+			:ibm_lazy_strike => IB::Option.new( symbol: 'IBM', exchange: 'SMART', right: :put, expiry: IB::Symbols::Futures.next_expiry ,
+																				 description: 'IBM-Option Chain ( quarterly expiry)'),
+
+	    :goog1100 => IB::Option.new( symbol: 'GOOG',
+					currency: 'USD',
+				  strike: 1100,
+				  multiplier: 100,
+				  right: :call,
+				  expiry:  IB::Symbols::Futures.next_expiry,
+				  description: 'Google Call Option with quarterly expiry'),
+	  :argo_ise => Option.new( symbol: 'ARGO',
+				  currency: "USD",
+				  exchange: "ISE",
+				  expiry:  IB::Symbols::Futures.next_expiry,
+				  right: :call,
+				  strike: 10,
+				  multiplier: 100,
+				  description: 'Adecoagro Options @ ISE'),
+		:san_eu => IB::Option.new(  symbol: 'SAN1',
+					exchange: "MEFFRV",
+					currency: "EUR",
+					expiry:  IB::Symbols::Futures.next_expiry,
+					strike: 4.5,
+					right: :call,
+#					multiplier: 100,  ## non standard multiplier: 102
+					trading_class: "SANEU",
+					description: 'Santanter Option specified via Trading-Class'),
+			:spy => IB::Option.new(:symbol => 'SPY',
+                                   :expiry => IB::Symbols::Futures.next_expiry,
+                                   :right => "P",
+                                   :currency => "USD",
+																	 :exchange => 'SMART',
+                                   :strike => 350,
+                                   :description => "SPY 350 Put next expiration"),
+#          :spy270 => IB::Option.new(:osi => 'SPY 190315P002700000'),
+#          :vix20 => IB::Option.new(:osi =>  'VIX 181121C00020000'),
+#          :vxx40 => IB::Option.new(:osi =>  'VXX 181117C00040000'),
+        }
+      end
+    end
+  end
+end

data/lib/ib/symbols/stocks.rb

@@ -0,0 +1,38 @@
+# Frequently used stock contracts definitions
+# TODO: auto-request :ContractDetails from IB if unknown symbol is requested?
+module IB
+  module Symbols
+    module Stocks
+      extend Symbols
+
+      def self.contracts
+ @contracts.presence || super.merge(
+	 :ib_smart =>   IB::Stock.new( symbol: 'IBKR', 
+																:description  => 'Interactive Brokers Stock with smart exchange setting'),
+	 :ib =>   IB::Stock.new( symbol: 'IBKR', exchange: 'ISLAND', 
+															 :description  => 'Interactive Brokers Stock'),
+	 :aapl => IB::Stock.new(:symbol => "AAPL",
+																:currency => "USD",
+																:description => "Apple Inc."),
+
+	 :msft => IB::Stock.new( symbol: 'MSFT', primary_exchange: 'ISLAND',
+																description: 'Apple, primary trading @ ISLAND'), ## primary exchange set
+	 :vxx =>	IB::Stock.new(:symbol => "VXX",
+																:exchange => "ARCA",
+																:description => "iPath S&P500 VIX short term Futures ETN"),
+	 :wfc =>	IB::Stock.new(:symbol => "WFC",
+																:exchange => "NYSE",
+																:currency => "USD",
+																:description => "Wells Fargo"),
+	:sie =>		IB::Stock.new( symbol: 'SIE', currency: 'EUR', 
+																description: 'Siemes AG'),
+	:wrong => IB::Stock.new(:symbol => "QEEUUE",
+															:exchange => "NYSE",
+															:currency => "USD",
+															:description => "Non-existent stock")
+														)
+			end
+
+		end
+	end
+end

data/lib/ib/symbols/version.rb

@@ -0,0 +1,5 @@
+module IB
+  module Symbols
+    VERSION = "1.0"
+  end
+end

data/lib/ib/symbols_base.rb

@@ -0,0 +1,58 @@
+
+module IB
+#  module SymbolExtention  # method_missing may not be refined
+#    refine Array do
+#      def method_missing(method, *key)
+#	unless method == :to_hash || method == :to_str #|| method == :to_int
+#	  return self.map{|x| x.public_send(method, *key)}
+#	end
+#      end
+#    end
+#  end 
+
+  module Symbols
+#    using SymbolExtention
+
+
+		def hardcoded?
+			!self.methods.include? :yml_file
+		end
+		def method_missing(method, *key)
+			if key.empty? 
+				if contracts.has_key?(method)
+					contracts[method]
+					elsif methods.include?(:each) && each.methods.include?(method)
+							self.each.send method  				
+					else
+					error "contract #{method} not defined. Try »all« for a list of defined Contracts.", :symbol
+				end
+			else
+				error "method missing"
+			end
+		end
+
+		def all
+			contracts.keys.sort rescue contracts.keys
+		end
+		def print_all
+			puts contracts.sort.map{|x,y| [x,y.description].join(" -> ")}.join "\n"
+		end
+		def contracts
+			if @contracts.present?
+				@contracts
+			else
+				@contracts = Hash.new
+			end
+		end
+		def [] symbol
+			if c=contracts[symbol]
+				return c
+			else
+				# symbol probably has not been predefined, tell user about it
+				file = self.to_s.split(/::/).last.downcase
+				msg = "Unknown symbol :#{symbol}, please pre-define it in lib/ib/symbols/#{file}.rb"
+				error msg, :symbol
+			end
+		end
+	end
+end

data/symbols/README.md

@@ -0,0 +1,20 @@
+This is the default directory of symbol-collections
+
+They are created through
+
+
+```
+cd bin
+./console
+
+# creates the file Test.yml
+i =  IB::Symbols.allocate_collection :Test
+
+# add a contract
+i.add_contract :testcontract , IB::Stock.new( symbol: 'TAP') 
+
+# list
+
+
+
+```

data/symbols/test.yml

@@ -0,0 +1,12 @@
+---
+:testcontract: !ruby/object:IB::Stock
+  attributes:
+    :symbol: GE
+    :con_id: 0
+    :exchange: SMART
+    :currency: USD
+    :sec_type: STK
+    :created_at: 2020-10-06 09:21:29.457747233 +00:00
+    :right: ''
+    :include_expired: false
+  description: 'Stock: GE USD'