wdevauld-ib-ruby 0.2

data/bin/RequestMarketData

@@ -0,0 +1,80 @@
+#!/usr/bin/env ruby -w
+#
+# Copyright (C) 2007 Paul Legato.
+# 
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of the
+# License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301 USA
+#
+
+$:.push(File.dirname(__FILE__) + "/../")
+
+require 'ib'
+require 'datatypes'
+require 'symbols/forex'
+
+#
+# Definition of what we want market data for.  We have to keep track
+# of what ticker id corresponds to what symbol ourselves, because the
+# ticks don't include any other identifying information.
+# 
+# The choice of ticker ids is, as far as I can tell, arbitrary.
+#
+@market = 
+  {
+    123 => IB::Symbols::Forex[:gbpusd],
+    456 => IB::Symbols::Forex[:eurusd]
+  }
+
+
+# First, connect to IB TWS.
+ib = IB::IB.new
+
+
+#
+# Now, subscribe to TickerPrice and TickerSize events.  The code
+# passed in the block will be executed when a message of that type is
+# received, with the received message as its argument. In this case,
+# we just print out the tick.
+# 
+# Note that we have to look the ticker id of each incoming message
+# up in local memory to figure out what it's for.
+#
+# (N.B. The description field is not from IB TWS. It is defined
+#  locally in forex.rb, and is just arbitrary text.)
+
+ib.subscribe(IB::IncomingMessages::TickPrice, lambda {|msg|
+               puts @market[msg.data[:ticker_id]].description + ": " + msg.to_human
+             })
+
+ib.subscribe(IB::IncomingMessages::TickSize, lambda {|msg|
+               puts @market[msg.data[:ticker_id]].description + ": " + msg.to_human
+             })
+
+
+# Now we actually request market data for the symbols we're interested in.
+
+@market.each_pair {|id, contract|
+  msg = IB::OutgoingMessages::RequestMarketData.new({
+                                                      :ticker_id => id,
+                                                      :contract => contract
+                                                    })
+  ib.dispatch(msg)
+}
+
+         
+puts "Main thread going to sleep. Press ^C to quit.."
+while true
+  sleep 2
+end

data/bin/SimpleTimeAndSales

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby -w
+#
+# Copyright (C) 2007 Paul Legato.
+# 
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of the
+# License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301 USA
+#
+
+$:.push(File.dirname(__FILE__) + "/../")
+
+require 'ib'
+require 'datatypes'
+require 'symbols/futures'
+
+# First, connect to IB TWS.
+ib = IB::IB.new
+
+# Uncomment this for verbose debug messages:
+# IB::IBLogger.level = Logger::Severity::DEBUG
+
+# Define the symbols we're interested in.
+@market = 
+  {
+    123 => IB::Symbols::Futures[:gbp],
+    234 => IB::Symbols::Futures[:jpy]
+  }
+
+
+# This method filters out non-:last type events, and filters out any
+# sale < MIN_SIZE.
+MIN_SIZE = 0
+
+def showSales(msg)
+  return if msg.data[:type] != :last || msg.data[:size] < MIN_SIZE
+  puts @market[msg.data[:ticker_id]].description + ": " + msg.data[:size].to_s + " at " + msg.data[:price].to_digits
+end
+
+def showSize(msg)
+  puts @market[msg.data[:ticker_id]].description + ": " + msg.to_human
+end
+
+
+#
+# Now, subscribe to TickerPrice and TickerSize events.  The code
+# passed in the block will be executed when a message of that type is
+# received, with the received message as its argument. In this case,
+# we just print out the tick.
+# 
+# Note that we have to look the ticker id of each incoming message
+# up in local memory to figure out what it's for.
+#
+# (N.B. The description field is not from IB TWS. It is defined
+#  locally in forex.rb, and is just arbitrary text.)
+
+ib.subscribe(IB::IncomingMessages::TickPrice, lambda {|msg|
+               showSales(msg)
+             })
+
+ib.subscribe(IB::IncomingMessages::TickSize, lambda {|msg|
+              showSize(msg)
+             })
+
+
+# Now we actually request market data for the symbols we're interested in.
+
+@market.each_pair {|id, contract|
+  msg = IB::OutgoingMessages::RequestMarketData.new({
+                                                      :ticker_id => id,
+                                                      :contract => contract
+                                                    })
+  ib.dispatch(msg)
+}
+
+         
+puts "\n\n\t******** Press <Enter> to quit.. *********\n\n"
+
+gets
+
+puts "Unsubscribing from TWS market data.."
+
+@market.each_pair {|id, contract|
+  msg = IB::OutgoingMessages::CancelMarketData.new({
+                                                      :ticker_id => id,
+                                                   })
+  ib.dispatch(msg)
+}
+
+puts "Done."
+

data/bin/ib-ruby

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(
+    File.join(File.dirname(__FILE__), %w[.. lib ib-ruby]))
+
+# Put your code here
+
+# EOF

data/lib/ib-ruby.rb

@@ -0,0 +1,49 @@
+
+module IbRuby
+
+  # :stopdoc:
+  VERSION = '1.0.0'
+  LIBPATH = ::File.expand_path(::File.dirname(__FILE__)) + ::File::SEPARATOR
+  PATH = ::File.dirname(LIBPATH) + ::File::SEPARATOR
+  # :startdoc:
+
+  # Returns the version string for the library.
+  #
+  def self.version
+    VERSION
+  end
+
+  # Returns the library path for the module. If any arguments are given,
+  # they will be joined to the end of the libray path using
+  # <tt>File.join</tt>.
+  #
+  def self.libpath( *args )
+    args.empty? ? LIBPATH : ::File.join(LIBPATH, args.flatten)
+  end
+
+  # Returns the lpath for the module. If any arguments are given,
+  # they will be joined to the end of the path using
+  # <tt>File.join</tt>.
+  #
+  def self.path( *args )
+    args.empty? ? PATH : ::File.join(PATH, args.flatten)
+  end
+
+  # Utility method used to rquire all files ending in .rb that lie in the
+  # directory below this file that has the same name as the filename passed
+  # in. Optionally, a specific _directory_ name can be passed in such that
+  # the _filename_ does not have to be equivalent to the directory.
+  #
+  def self.require_all_libs_relative_to( fname, dir = nil )
+    dir ||= ::File.basename(fname, '.*')
+    search_me = ::File.expand_path(
+        ::File.join(::File.dirname(fname), dir, '**', '*.rb'))
+
+    Dir.glob(search_me).sort.each {|rb| require rb}
+  end
+
+end  # module IbRuby
+
+IbRuby.require_all_libs_relative_to(__FILE__)
+
+# EOF

data/lib/ib-ruby/datatypes.rb

@@ -0,0 +1,402 @@
+#
+# Copyright (C) 2006 Blue Voodoo Magic LLC.
+#
+# This library is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as
+# published by the Free Software Foundation; either version 2.1 of the
+# License, or (at your option) any later version.
+#
+# This library is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+# Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public
+# License along with this library; if not, write to the Free Software
+# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+# 02110-1301 USA
+#
+
+#
+# TODO: Implement equals() according to the criteria in IB's Java client.
+#
+
+require 'Logger'
+
+module IB
+
+  logger = Logger.new(STDERR)
+
+  module Datatypes
+    attr_reader :created_at
+
+    class AbstractDatum
+      def init
+        @created_at = Time.now
+      end
+
+      # If a hash is given, keys are taken as attribute names, values as data.
+      # The attrs of the instance are set automatically from the attributeHash.
+      #
+      # If no hash is given, #init is called in the instance. #init
+      # should set the datum up in a generic state.
+      #
+      def initialize(attributeHash=nil)
+        if attributeHash.nil?
+          init
+        else
+          raise(ArgumentError.new("Argument must be a Hash")) unless attributeHash.is_a?(Hash)
+          attributeHash.keys.each {|key|
+            self.send((key.to_s + "=").to_sym, attributeHash[key])
+          }
+        end
+      end
+    end # AbstractDatum
+
+
+    # This is used within HistoricData messages.
+    # Instantiate with a Hash of attributes, to be auto-set via initialize in AbstractDatum.
+    class Bar < AbstractDatum
+      attr_accessor :date, :open, :high, :low, :close, :volume, :wap, :has_gaps
+
+      def to_s
+        "<Bar: #{@date}; OHLC: #{@open.to_digits}, #{@high.to_digits}, #{@low.to_digits}, #{@close.to_digits}; volume: #{@volume}; wap: #{@wap.to_digits}; has_gaps: #{@has_gaps}>"
+      end
+
+    end # Bar
+
+
+    class Order < AbstractDatum
+      # Constants used in Order objects. Drawn from Order.java
+      Origin_Customer = 0
+      Origin_Firm = 1
+
+      Opt_Unknown = '?'
+      Opt_Broker_Dealer = 'b'
+      Opt_Customer = 'c'
+      Opt_Firm = 'f'
+      Opt_Isemm = 'm'
+      Opt_Farmm = 'n'
+      Opt_Specialist = 'y'
+
+      # Main order fields
+      attr_accessor(:id, :client_id, :perm_id, :action, :total_quantity, :order_type, :limit_price,
+                    :aux_price, :shares_allocation)
+
+      # Extended order fields
+      attr_accessor(:tif, :oca_group, :account, :open_close, :origin, :order_ref,
+                    :transmit,   # if false, order will be created but not transmitted.
+                    :parent_id,  # Parent order id, to associate auto STP or TRAIL orders with the original order.
+                    :block_order,
+                    :sweep_to_fill,
+                    :display_size,
+                    :trigger_method,
+                    :ignore_rth,
+                    :hidden,
+                    :discretionary_amount,
+                    :good_after_time,
+                    :good_till_date)
+
+      OCA_Cancel_with_block = 1
+      OCA_Reduce_with_block = 2
+      OCA_Reduce_non_block = 3
+
+      # No idea what the fa_* attributes are for, nor many of the others.
+      attr_accessor(:fa_group, :fa_profile, :fa_method, :fa_profile, :fa_method, :fa_percentage, :primary_exchange,
+                    :short_sale_slot,     # 1 or 2, says Order.java. (No idea what the difference is.)
+                    :designated_location, # "when slot=2 only"
+                    :oca_type, # 1 = CANCEL_WITH_BLOCK, 2 = REDUCE_WITH_BLOCK, 3 = REDUCE_NON_BLOCK
+                    :rth_only, :override_percentage_constraints, :rule_80a, :settling_firm, :all_or_none,
+                    :min_quantity, :percent_offset, :etrade_only, :firm_quote_only, :nbbo_price_cap)
+
+      # Box orders only:
+      Box_Auction_Match = 1
+      Box_Auction_Improvement = 2
+      Box_Auction_Transparent = 3
+      attr_accessor(:auction_strategy,  # Box_* constants above
+                    :starting_price, :stock_ref_price, :delta, :stock_range_lower, :stock_range_upper)
+
+      # Volatility orders only:
+      Volatility_Type_Daily = 1
+      Volatility_Type_Annual = 2
+
+      Volatility_Ref_Price_Average = 1
+      Volatility_Ref_Price_BidOrAsk = 2
+
+      attr_accessor(:volatility,
+                    :volatility_type, # 1 = daily, 2 = annual, as above
+                    :continuous_update,
+                    :reference_price_type, # 1 = average, 2 = BidOrAsk
+                    :delta_neutral_order_type,
+                    :delta_neutral_aux_price)
+
+      Max_value = 99999999 # I don't know why IB uses a very large number as the default for certain fields
+      def init
+        super
+
+        @open_close = "0"
+        @origin = Origin_Customer
+        @transmit = true
+        @primary_exchange = ''
+        @designated_location = ''
+        @min_quantity = Max_value
+        @percent_offset = Max_value
+        @nbba_price_cap = Max_value
+        @starting_price = Max_value
+        @stock_ref_price = Max_value
+        @delta = Max_value
+        @delta_neutral_order_type = ''
+        @delta_neutral_aux_price = Max_value
+        @reference_price_type = Max_value
+      end # init
+
+    end # class Order
+
+
+    class Contract < AbstractDatum
+
+      # Valid security types (sec_type attribute)
+      SECURITY_TYPES =
+        {
+          :stock => "STK",
+          :option => "OPT",
+          :future => "FUT",
+          :index => "IND",
+          :futures_option => "FOP",
+          :forex => "CASH",
+          :bag => "BAG"
+        }
+
+      # note that the :description field is entirely local to ib-ruby, and not part of TWS.
+      # You can use it to store whatever arbitrary data you want.
+
+      attr_accessor(:symbol, :strike, :multiplier, :exchange, :currency,
+                    :local_symbol, :combo_legs, :description)
+
+      # Bond values
+      attr_accessor(:cusip, :ratings, :desc_append, :bond_type, :coupon_type, :callable, :puttable,
+                    :coupon, :convertible, :maturity, :issue_date)
+
+      attr_reader :sec_type, :expiry, :right, :primary_exchange
+
+
+
+      # some protective filters
+
+      def primary_exchange=(x)
+        x.upcase! if x.is_a?(String)
+
+        # per http://chuckcaplan.com/twsapi/index.php/Class%20Contract
+        raise(ArgumentError.new("Don't set primary_exchange to smart")) if x == "SMART"
+
+        @primary_exchange = x
+      end
+
+      def right=(x)
+        x.upcase! if x.is_a?(String)
+        x = nil if !x.nil? && x.empty?
+        raise(ArgumentError.new("Invalid right \"#{x}\" (must be one of PUT, CALL, P, C)"))  unless x.nil? || [ "PUT", "CALL", "P", "C"].include?(x)
+        @right = x
+      end
+
+      def expiry=(x)
+        x = nil if !x.nil? && x.empty?
+        raise(ArgumentError.new("Invalid expiry \"#{x}\" (must be in format YYYYMM or YYYYMMDD)"))  unless x.nil? || x.to_s =~ /^\d\d\d\d\d\d(\d\d)?$/
+        @expiry = x.to_s
+      end
+
+      def sec_type=(x)
+        x = nil if !x.nil? && x.empty?
+        raise(ArgumentError.new("Invalid security type \"#{x}\" (see SECURITY_TYPES constant in Contract class for valid types)"))  unless x.nil? || SECURITY_TYPES.values.include?(x)
+        @sec_type = x
+      end
+
+      def reset
+        @combo_legs = Array.new
+        @strike = 0
+      end
+
+      # Different messages serialize contracts differently. Go figure.
+      def serialize_short(version)
+        q = [ self.symbol,
+              self.sec_type,
+              self.expiry,
+              self.strike,
+              self.right ]
+
+        q.push(self.multiplier) if version >= 15
+        q.concat([
+                  self.exchange,
+                  self.currency,
+                  self.local_symbol
+                 ])
+
+        q
+      end # serialize
+
+      # This returns an Array of data from the given contract, in standard format.
+      # Note that it does not include the combo legs.
+      def serialize_long(version)
+        queue = [
+                  self.symbol,
+                  self.sec_type,
+                  self.expiry,
+                  self.strike,
+                  self.right
+                ]
+
+        queue.push(self.multiplier) if version >= 15
+        queue.push(self.exchange)
+        queue.push(self.primary_exchange) if version >= 14
+        queue.push(self.currency)
+        queue.push(self.local_symbol) if version >= 2
+
+        queue
+      end # serialize_long
+
+      #
+      # This produces a string uniquely identifying this contract, in the format used
+      # for command line arguments in the IB-Ruby examples. The format is:
+      #
+      #    symbol:security_type:expiry:strike:right:multiplier:exchange:primary_exchange:currency:local_symbol
+      #
+      # Fields not needed for a particular security should be left blank (e.g. strike and right are only relevant for options.)
+      #
+      # For example, to query the British pound futures contract trading on Globex expiring in September, 2008,
+      # the string is:
+      #
+      #    GBP:FUT:200809:::62500:GLOBEX::USD:
+      #
+
+      def serialize_ib_ruby(version)
+        serialize_long(version).join(":")
+      end
+
+      # This returns a Contract initialized from the serialize_ib_ruby format string.
+      def self.from_ib_ruby(string)
+        c = Contract.new
+        c.symbol, c.sec_type, c.expiry, c.strike, c.right, c.multiplier, c.exchange, c.primary_exchange, c.currency, c.local_symbol = string.split(":")
+
+        c
+      end
+
+      # Some messages send open_close too, some don't. WTF.
+      def serialize_combo_legs(include_open_close = false)
+        if self.combo_legs.nil?
+          [0]
+        else
+          [ self.combo_legs.size ].concat(self.combo_legs.serialize(include_open_close))
+        end
+      end
+
+      def init
+        super
+
+        @combo_legs = Array.new
+        @strike = 0
+        @sec_type = ''
+      end
+
+      def to_human
+        "<IB-Contract: " + [symbol, expiry, sec_type, strike, right, exchange, currency].join("-") + "}>"
+      end
+
+      def to_short
+        "#{symbol}#{expiry}#{strike}#{right}#{exchange}#{currency}"
+      end
+
+      def to_s
+        to_human
+      end
+
+    end # class Contract
+
+
+    class ContractDetails < AbstractDatum
+      attr_accessor :summary, :market_name, :trading_class, :con_id, :min_tick, :multiplier, :price_magnifier, :order_types, :valid_exchanges
+
+      def init
+        super
+
+        @summary = Contract.new
+        @con_id = 0
+        @min_tick = 0
+      end
+    end # class ContractDetails
+
+
+    class Execution < AbstractDatum
+      attr_accessor :order_id, :client_id, :exec_id, :time, :account_number, :exchange, :side, :shares, :price, :perm_id, :liquidation
+
+      def init
+        super
+
+        @order_id = 0
+        @client_id = 0
+        @shares = 0
+        @price = 0
+        @perm_id = 0
+        @liquidation =0
+      end
+    end # Execution
+
+    # EClientSocket.java tells us: 'Note that the valid format for m_time is "yyyymmdd-hh:mm:ss"'
+    class ExecutionFilter < AbstractDatum
+      attr_accessor :client_id, :acct_code, :time, :symbol, :sec_type, :exchange, :side
+
+      def init
+        super
+
+        @client_id = 0
+      end
+
+    end # ExecutionFilter
+
+
+    class ComboLeg < AbstractDatum
+      attr_accessor :con_id, :ratio, :action, :exchange, :open_close
+
+      def init
+        super
+
+        @con_id = 0
+        @ratio = 0
+        @open_close = 0
+      end
+
+      # Some messages include open_close, some don't. wtf.
+      def serialize(include_open_close = false)
+        self.collect { |leg|
+          [ leg.con_id, leg.ratio, leg.action, leg.exchange, (include_open_close ? leg.open_close : [] )]
+        }.flatten
+      end
+    end # ComboLeg
+
+
+    class ScannerSubscription < AbstractDatum
+      attr_accessor :number_of_rows, :instrument, :location_code, :scan_code, :above_price, :below_price,
+                    :above_volume, :average_option_volume_above, :market_cap_above, :market_cap_below, :moody_rating_above,
+                    :moody_rating_below, :sp_rating_above, :sp_rating_below, :maturity_date_above, :maturity_date_below,
+                    :coupon_rate_above, :coupon_rate_below, :exclude_convertible, :scanner_setting_pairs, :stock_type_filter
+
+      def init
+        super
+
+        @coupon_rate_above = @coupon_rate_below = @market_cap_below = @market_cap_above = @average_option_volume_above =
+          @above_volume = @below_price = @above_price = nil
+        @number_of_rows = -1 # none specified, per ScannerSubscription.java
+      end
+    end # ScannerSubscription
+
+
+    # Just like a Hash, but throws an exception if you try to access a key that doesn't exist.
+    class StringentHash < Hash
+      def initialize(hash)
+        super() {|hash,key| raise Exception.new("key #{key.inspect} not found!") }
+        self.merge!(hash) unless hash.nil?
+      end
+    end
+
+  end # module Datatypes
+
+end # module