ib-ruby 0.4.3 → 0.4.20

data/lib/ib-ruby/datatypes.rb

@@ -1,400 +0,0 @@
-#
-# 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.
-#
-
-module IB
-
-  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_s}, #{@high.to_s}, #{@low.to_s}, #{@close.to_s}; volume: #{@volume}; wap: #{@wap.to_s}; 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", "0"].include?(x)
-        @right = x
-      end
-
-      def expiry=(x)
-	x = x.to_s
-	if (x.nil? || ! (x =~ /\d{6,8}/)) and !x.empty? then
-		raise ArgumentError.new("Invalid expiry \"#{x}\" (must be in format YYYYMM or YYYYMMDD)")
-	end
- 	@expiry = x	
-      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

data/lib/ib-ruby/ib.rb

@@ -1,242 +0,0 @@
-#
-# 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
-#
-
-require 'sha1'
-require 'socket'
-require 'logger'
-require 'bigdecimal'
-require 'bigdecimal/util'
-
-# Add method to_ib to render datetime in IB format (zero padded "yyyymmdd HH:mm:ss")
-class Time
-  def to_ib
-    "#{self.year}#{sprintf("%02d", self.month)}#{sprintf("%02d", self.day)} " +
-    "#{sprintf("%02d", self.hour)}:#{sprintf("%02d", self.min)}:#{sprintf("%02d", self.sec)}"
-  end
-end # Time
-
-
-module IB
-
-  TWS_IP_ADDRESS = "127.0.0.1"
-  TWS_PORT = "7496"
-
-  #logger = Logger.new(STDERR)
-
-  class IBSocket < TCPSocket
-
-    # send nice null terminated binary data
-    def send(data)
-      self.syswrite(data.to_s + "\0")
-    end
-
-    def read_string
-      self.gets("\0").chop
-    end
-
-    def read_int
-      self.read_string.to_i
-    end
-
-    def read_boolean
-      self.read_string.to_i != 0
-    end
-
-    # Floating-point numbers shouldn't be used to store money.
-    def read_decimal
-      self.read_string.to_d
-    end
-
-  end # class IBSocket
-
-
-
-  class IB
-    Tws_client_version = 27
-
-    attr_reader :next_order_id
-
-    def initialize(options_in = {})
-      @options = {
-        :ip => TWS_IP_ADDRESS,
-        :port => TWS_PORT,
-      }.merge(options_in)
-
-      @connected = false
-      @next_order_id = nil
-      @server = Hash.new # information about server and server connection state
-
-      # Message listeners.
-      # Key is the message class to listen for.
-      # Value is an Array of Procs. The proc will be called with the populated message instance as its argument when
-      # a message of that type is received.
-      @listeners = Hash.new { |hash, key|
-        hash[key] = Array.new
-      }
-
-
-      #logger.debug("IB#init: Initializing...")
-
-      self.open(@options)
-
-    end # init
-
-    def server_version
-      @server[:version]
-    end
-
-
-    def open(options_in = {})
-      raise Exception.new("Already connected!") if @connected
-
-      opts = {
-        :ip => "127.0.0.1",
-        :port => "7496"
-      }.merge(options_in)
-
-
-      # Subscribe to the NextValidID message from TWS that is always
-      # sent at connect, and save the id.
-      self.subscribe(IncomingMessages::NextValidID, lambda {|msg|
-                       @next_order_id = msg.data[:order_id]
-                       #logger.info { "Got next valid order id #{@next_order_id}." }
-                     })
-
-      @server[:socket] = IBSocket.open(@options[:ip], @options[:port])
-      #logger.info("* TWS socket connected to #{@options[:ip]}:#{@options[:port]}.")
-
-      # Sekrit handshake.
-      #logger.debug("\tSending client version #{Tws_client_version}..")
-
-      @server[:socket].send(Tws_client_version)
-      @server[:version] = @server[:socket].read_int
-      @@server_version = @server[:version]
-      @server[:local_connect_time] = Time.now()
-
-      #logger.debug("\tGot server version: #{@server[:version]}.")
-
-      # Server version >= 20 sends the server time back.
-      if @server[:version] >= 20
-        @server[:remote_connect_time] = @server[:socket].read_string
-        #logger.debug("\tServer connect time: #{@server[:remote_connect_time]}.")
-      end
-
-      # Server version >= 3 wants an arbitrary client ID at this point. This can be used
-      # to identify subsequent communications.
-      if @server[:version] >= 3
-        @server[:client_id] = SHA1.digest(Time.now.to_s + $$.to_s).unpack("C*").join.to_i % 999999999
-        @server[:socket].send(@server[:client_id])
-        #logger.debug("\tSent client id # #{@server[:client_id]}.")
-      end
-
-      #logger.debug("Starting reader thread..")
-      Thread.abort_on_exception = true
-      @server[:reader_thread] = Thread.new {
-        self.reader
-      }
-
-      @connected = true
-    end
-
-
-
-    def close
-      @server[:reader_thread].kill # Thread uses blocking I/O, so join is useless.
-      @server[:socket].close()
-      @server = Hash.new
-      @@server_version = nil
-      @connected = false
-      #logger.debug("Disconnected.")
-    end # close
-
-
-
-    def to_s
-      "IB Connector: #{ @connected ? "connected." : "disconnected."}"
-    end
-
-
-
-    # Subscribe to incoming message events of type messageClass.
-    # code is a Proc that will be called with the message instance as its argument.
-    def subscribe(messageClass, code)
-      raise(Exception.new("Invalid argument type (#{messageClass}, #{code.class}) - " +
-                          " must be (IncomingMessages::AbstractMessage, Proc)")) unless
-        messageClass <= IncomingMessages::AbstractMessage && code.is_a?(Proc)
-
-      @listeners[messageClass].push(code)
-    end
-
-
-
-    # Send an outgoing message.
-    def dispatch(message)
-      raise Exception.new("dispatch() must be given an OutgoingMessages::AbstractMessage subclass") unless
-        message.is_a?(OutgoingMessages::AbstractMessage)
-
-      #logger.info("Sending message " + message.inspect)
-      message.send(@server)
-    end
-
-
-
-    protected
-
-    def reader
-      #logger.debug("Reader started.")
-
-      while true
-        msg_id = @server[:socket].read_int # this blocks, so Thread#join is useless.
-        #logger.debug { "Reader: got message id #{msg_id}.\n" }
-
-        # create a new instance of the appropriate message type, and have it read the message.
-        msg = IncomingMessages::Table[msg_id].new(@server[:socket], @server[:version])
-
-        @listeners[msg.class].each { |listener|
-          listener.call(msg)
-        }
-
-        #logger.debug { " Listeners: " + @listeners.inspect + " inclusion: #{ @listeners.include?(msg.class)}" }
-
-        # Log the message if it's an error.
-        # Make an exception for the "successfully connected" messages, which, for some reason, come back from IB as errors.
-        if msg.is_a?(IncomingMessages::Error)
-          if msg.code == 2104 || msg.code == 2106 # connect strings
-            #logger.info(msg.to_human)
-          else
-            #logger.error(msg.to_human)
-          end
-        else
-          # Warn if nobody listened to a non-error incoming message.
-          unless @listeners[msg.class].size > 0
-            #logger.warn { " WARNING: Nobody listened to incoming message #{msg.class}" }
-          end
-        end
-
-
-        # #logger.debug("Reader done with message id #{msg_id}.")
-
-
-      end # while
-
-      #logger.debug("Reader done.")
-    end # reader
-
-  end # class IB
-end # module IB