ib-api 972.0

data/lib/ib/connection.rb

@@ -0,0 +1,450 @@
+require 'thread'
+#require 'active_support'
+require 'ib/socket'
+require 'ib/logger'
+require 'ib/messages'
+
+module IB
+  # Encapsulates API connection to TWS or Gateway
+  class Connection
+
+
+  ## -------------------------------------------- Interface ---------------------------------
+  ## public attributes: socket, next_local_id ( alias next_order_id)
+  ## public methods:  connect (alias open), disconnect, connected?
+  ##		      subscribe, unsubscribe
+  ##		      send_message (alias dispatch)
+  ##		      place_order, modify_order, cancel_order
+  ## public data-queue: received,  received?, wait_for, clear_received
+  ## misc:	      reader_running?
+
+  include LogDev   # provides default_logger
+
+    mattr_accessor :current
+    mattr_accessor :logger  ## borrowed from active_support
+    # Please note, we are realizing only the most current TWS protocol versions,
+    # thus improving performance at the expense of backwards compatibility.
+    # Older protocol versions support can be found in older gem versions.
+
+    attr_accessor  :socket #   Socket to IB server (TWS or Gateway)
+    attr_accessor  :next_local_id # Next valid order id
+    attr_accessor  :client_id
+    attr_accessor  :server_version
+    attr_accessor  :client_version
+    alias next_order_id next_local_id
+    alias next_order_id= next_local_id=
+
+    def initialize host: '127.0.0.1',
+                   port: '4002', # IB Gateway connection (default --> demo) 4001:  production
+                       #:port => '7497', # TWS connection  --> demo				  7496:  production
+                   connect: true, # Connect at initialization
+                   received:  true, # Keep all received messages in a @received Hash
+#									 redis: false,    # future plans
+                   logger: default_logger,
+                   client_id:  rand( 1001 .. 9999 ) ,
+                   client_version: IB::Messages::CLIENT_VERSION,	# lib/ib/server_versions.rb
+									 optional_capacities: "", # TWS-Version 974: "+PACEAPI"
+                   #server_version: IB::Messages::SERVER_VERSION, # lib/messages.rb
+		   **any_other_parameters_which_are_ignored
+			 # V 974 release motes
+# API messages sent at a higher rate than 50/second can now be paced by TWS at the 50/second rate instead of potentially causing a disconnection. This is now done automatically by the RTD Server API and can be done with other API technologies by invoking SetConnectOptions("+PACEAPI") prior to eConnect.
+
+
+    # convert parameters into instance-variables and assign them
+		method(__method__).parameters.each do |type, k|
+			next unless type == :key
+			case k
+			when :logger
+				self.logger = logger
+			else
+				v = eval(k.to_s)
+				instance_variable_set("@#{k}", v) unless v.nil?
+			end
+		end
+
+		# A couple of locks to avoid race conditions in JRuby
+		@subscribe_lock = Mutex.new
+		@receive_lock = Mutex.new
+		@message_lock = Mutex.new
+
+		@connected = false
+		self.next_local_id = nil
+
+		#     self.subscribe(:Alert) do |msg|
+		#       puts msg.to_human
+		#     end
+
+		# TWS always sends NextValidId message at connect -subscribe save this id
+		## this block is executed before tws-communication is established
+		yield self if block_given?
+
+		self.subscribe(:NextValidId) do |msg|
+			logger.progname = "Connection#connect"
+			self.next_local_id = msg.local_id
+			logger.info { "Got next valid order id: #{next_local_id}." }
+		end
+
+		# Ensure the transmission of NextValidId.
+		# works even if no reader_thread is established
+		if connect
+			disconnect if connected?
+			 update_next_order_id
+			Kernel.exit if self.next_local_id.nil?
+		end
+		#start_reader if @received && connected?
+		Connection.current = self
+		end
+
+		# read actual order_id and
+		# connect if not connected
+		def update_next_order_id
+			i,finish = 0, false
+			sub = self.subscribe(:NextValidID) { finish =  true }
+			connected? ?  self.send_message( :RequestIds )  : open()
+			Timeout::timeout(1, IB::TransmissionError,"Could not get NextValidId" ) do
+				loop { sleep 0.1; break if finish  }
+			end
+			self.unsubscribe sub
+		end
+
+		### Working with connection
+
+		def connect
+			logger.progname='IB::Connection#connect'
+			if connected?
+				error  "Already connected!"
+				return
+			end
+
+			self.socket = IBSocket.open(@host, @port)  # raises  Errno::ECONNREFUSED  if no connection is possible
+			socket.initialising_handshake
+			socket.decode_message( socket.recieve_messages ) do  | the_message |
+				#				logger.info{ "TheMessage :: #{the_message.inspect}" }
+				@server_version =  the_message.shift.to_i
+				error "ServerVersion does not match  #{@server_version} <--> #{MAX_CLIENT_VER}" if @server_version != MAX_CLIENT_VER
+
+				@remote_connect_time = DateTime.parse the_message.shift
+				@local_connect_time = Time.now
+			end
+
+			# Sending (arbitrary) client ID to identify subsequent communications.
+			# The client with a client_id of 0 can manage the TWS-owned open orders.
+			# Other clients can only manage their own open orders.
+
+			# V100 initial handshake
+			# Parameters borrowed from the python client
+			start_api = 71
+			version = 2
+			#			optcap = @optional_capacities.empty? ? "" : " "+ @optional_capacities
+			socket.send_messages start_api, version, @client_id  , @optional_capacities
+			@connected = true
+			logger.info { "Connected to server, version: #{@server_version},\n connection time: " +
+								 "#{@local_connect_time} local, " +
+									 "#{@remote_connect_time} remote."}
+
+			# if the client_id is wrong or the port is not accessible the first read attempt fails
+			# get the first message and proceed if something reasonable is recieved
+			the_message = process_message   # recieve next_order_id
+			error "Check Port/Client_id ", :reader if the_message == " "
+			start_reader
+		end
+
+    alias open connect # Legacy alias
+
+    def disconnect
+      if reader_running?
+        @reader_running = false
+        @reader_thread.join
+      end
+      if connected?
+        socket.close
+        @connected = false
+      end
+    end
+
+    alias close disconnect # Legacy alias
+
+    def connected?
+      @connected
+    end
+
+    ### Working with message subscribers
+
+    # Subscribe Proc or block to specific type(s) of incoming message events.
+    # Listener will be called later with received message instance as its argument.
+    # Returns subscriber id to allow unsubscribing
+    def subscribe *args, &block
+      @subscribe_lock.synchronize do
+        subscriber = args.last.respond_to?(:call) ? args.pop : block
+        id = random_id
+
+        error  "Need subscriber proc or block ", :args  unless subscriber.is_a? Proc
+
+        args.each do |what|
+          message_classes =
+          case
+          when what.is_a?(Class) && what < Messages::Incoming::AbstractMessage
+            [what]
+          when what.is_a?(Symbol)
+            [Messages::Incoming.const_get(what)]
+          when what.is_a?(Regexp)
+            Messages::Incoming::Classes.values.find_all { |klass| klass.to_s =~ what }
+          else
+            error  "#{what} must represent incoming IB message class", :args
+          end
+     # @subscribers_lock.synchronize do
+          message_classes.flatten.each do |message_class|
+            # TODO: Fix: RuntimeError: can't add a new key into hash during iteration
+            subscribers[message_class][id] = subscriber
+          end
+     # end  # lock
+        end
+
+        id
+      end
+    end
+
+    # Remove all subscribers with specific subscriber id
+		def unsubscribe *ids
+			@subscribe_lock.synchronize do
+				ids.collect do |id|
+					removed_at_id = subscribers.map { |_, subscribers| subscribers.delete id }.compact
+					logger.error  "No subscribers with id #{id}"   if removed_at_id.empty?
+					removed_at_id # return_value
+				end.flatten
+			end
+		end
+    ### Working with received messages Hash
+
+    # Clear received messages Hash
+    def clear_received *message_types
+      @receive_lock.synchronize do
+        if message_types.empty?
+          received.each { |message_type, container| container.clear }
+        else
+          message_types.each { |message_type| received[message_type].clear }
+        end
+      end
+    end
+
+    # Hash of received messages, keyed by message type
+    def received
+      @received_hash ||= Hash.new do |hash, message_type|
+				# enable access to the hash via
+				# ib.received[:MessageType].attribute
+				the_array = Array.new
+				def the_array.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
+			hash[message_type] = the_array
+			end
+    end
+
+    # Check if messages of given type were received at_least n times
+    def received? message_type, times=1
+      @receive_lock.synchronize do
+        received[message_type].size >= times
+      end
+    end
+
+
+    # Wait for specific condition(s) - given as callable/block, or
+    # message type(s) - given as Symbol or [Symbol, times] pair.
+    # Timeout after given time or 1 second.
+		#
+		# wait_for depends heavyly on Connection#received. If collection of messages through recieved
+		# is turned off, wait_for loses most of its functionality
+    def wait_for *args, &block
+      timeout = args.find { |arg| arg.is_a? Numeric } # extract timeout from args
+      end_time = Time.now + (timeout || 1) # default timeout 1 sec
+      conditions = args.delete_if { |arg| arg.is_a? Numeric }.push(block).compact
+
+      until end_time < Time.now || satisfied?(*conditions)
+        if reader_running?
+          sleep 0.05
+        else
+          process_messages 50
+        end
+      end
+    end
+
+    ### Working with Incoming messages from IB
+
+
+    def reader_running?
+      @reader_running && @reader_thread && @reader_thread.alive?
+    end
+
+    # Process incoming messages during *poll_time* (200) msecs, nonblocking
+    def process_messages poll_time = 50 # in msec
+      time_out = Time.now + poll_time/1000.0
+      while (time_left = time_out - Time.now) > 0
+        # If socket is readable, process single incoming message
+				#process_message if select [socket], nil, nil, time_left
+				# the following  checks for shutdown of TWS side; ensures we don't run in a spin loop.
+				# unfortunately, it raises Errors in windows environment
+				# disabled for now
+        if select [socket], nil, nil, time_left
+        #  # Peek at the message from the socket; if it's blank then the
+        #  # server side of connection (TWS) has likely shut down.
+          socket_likely_shutdown = socket.recvmsg(100, Socket::MSG_PEEK)[0] == ""
+				#
+        #  # We go ahead process messages regardless (a no-op if socket_likely_shutdown).
+          process_message
+        #
+        #  # After processing, if socket has shut down we sleep for 100ms
+        #  # to avoid spinning in a tight loop. If the server side somehow
+        #  # comes back up (gets reconnedted), normal processing
+        #  # (without the 100ms wait) should happen.
+         sleep(0.1) if socket_likely_shutdown
+        end
+      end
+    end
+
+    ### Sending Outgoing messages to IB
+
+    # Send an outgoing message.
+		# returns the used request_id if appropiate, otherwise "true"
+    def send_message what, *args
+      message =
+      case
+      when what.is_a?(Messages::Outgoing::AbstractMessage)
+        what
+      when what.is_a?(Class) && what < Messages::Outgoing::AbstractMessage
+        what.new *args
+      when what.is_a?(Symbol)
+        Messages::Outgoing.const_get(what).new *args
+      else
+        error "Only able to send outgoing IB messages", :args
+      end
+      error   "Not able to send messages, IB not connected!"  unless connected?
+			begin
+      @message_lock.synchronize do
+      message.send_to socket
+      end
+			rescue Errno::EPIPE
+				logger.error{ "Broken Pipe, trying to reconnect"  }
+				disconnect
+				connect
+				retry
+			end
+			## return the transmitted message
+		  message.data[:request_id].presence || true
+    end
+
+    alias dispatch send_message # Legacy alias
+
+    # Place Order (convenience wrapper for send_message :PlaceOrder).
+    # Assigns client_id and order_id fields to placed order. Returns assigned order_id.
+    def place_order order, contract
+     # order.place contract, self  ## old
+      error "Unable to place order, next_local_id not known" unless next_local_id
+			error "local_id present. Order is already placed.  Do might use  modify insteed"  unless  order.local_id.nil?
+      order.client_id = client_id
+      order.local_id = next_local_id
+      self.next_local_id += 1
+      order.placed_at = Time.now
+			modify_order order, contract
+    end
+
+    # Modify Order (convenience wrapper for send_message :PlaceOrder). Returns order_id.
+    def modify_order order, contract
+ #      order.modify contract, self    ## old
+			error "Unable to modify order; local_id not specified" if order.local_id.nil?
+      order.modified_at = Time.now
+      send_message :PlaceOrder,
+        :order => order,
+        :contract => contract,
+        :local_id => order.local_id
+      order.local_id  # return value
+    end
+
+    # Cancel Orders by their local ids (convenience wrapper for send_message :CancelOrder).
+    def cancel_order *local_ids
+      local_ids.each do |local_id|
+        send_message :CancelOrder, :local_id => local_id.to_i
+      end
+    end
+
+    # Start reader thread that continuously reads messages from @socket in background.
+    # If you don't start reader, you should manually poll @socket for messages
+    # or use #process_messages(msec) API.
+    def start_reader
+			return(@reader_thread) if @reader_running
+			if connected?
+				Thread.abort_on_exception = true
+				@reader_running = true
+				@reader_thread = Thread.new { process_messages while @reader_running }
+			else
+				logger.fatal {"Could not start reader, not connected!"}
+				nil  # return_value
+			end
+    end
+
+		protected
+		# Message subscribers. Key is the message class to listen for.
+		# Value is a Hash of subscriber Procs, keyed by their subscription id.
+		# All subscriber Procs will be called with the message instance
+		# as an argument when a message of that type is received.
+		def subscribers
+			@subscribers ||= Hash.new { |hash, subs| hash[subs] = Hash.new }
+		end
+
+		# Process single incoming message (blocking!)
+		def process_message
+			logger.progname='IB::Connection#process_message' if logger.is_a?(Logger)
+
+			socket.decode_message(  socket.recieve_messages ) do | the_decoded_message |
+				#	puts "THE deCODED MESSAGE #{ the_decoded_message.inspect}"
+				msg_id = the_decoded_message.shift.to_i
+
+				# Debug:
+				logger.debug { "Got message #{msg_id} (#{Messages::Incoming::Classes[msg_id]})"}
+
+				# Create new instance of the appropriate message type,
+				# and have it read the message from socket.
+				# NB: Failure here usually means unsupported message type received
+				logger.error { "Got unsupported message #{msg_id}" } unless Messages::Incoming::Classes[msg_id]
+				error "Something strange happened - Reader has to be restarted" , :reader if msg_id.to_i.zero?
+				msg = Messages::Incoming::Classes[msg_id].new(the_decoded_message)
+
+				# Deliver message to all registered subscribers, alert if no subscribers
+				# Ruby 2.0 and above: Hashes are ordered.
+				# Thus first declared subscribers of  a class are executed first
+				@subscribe_lock.synchronize do
+					subscribers[msg.class].each { |_, subscriber| subscriber.call(msg) }
+				end
+				logger.warn { "No subscribers for message #{msg.class}!" } if subscribers[msg.class].empty?
+
+				# Collect all received messages into a @received Hash
+				if @received
+					@receive_lock.synchronize do
+						received[msg.message_type] << msg
+					end
+				end
+			end
+		end
+
+		def random_id
+			rand 999999
+		end
+
+		# Check if all given conditions are satisfied
+		def satisfied? *conditions
+			!conditions.empty? &&
+				conditions.inject(true) do |result, condition|
+				result && if condition.is_a?(Symbol)
+				received?(condition)
+			elsif condition.is_a?(Array)
+				received?(*condition)
+			elsif condition.respond_to?(:call)
+				condition.call
+			else
+				logger.error { "Unknown wait condition #{condition}" }
+			end
+		end
+	end
+end # class Connection
+end # module IB

data/lib/ib/constants.rb

@@ -0,0 +1,393 @@
+module IB
+  ### Widely used TWS constants:
+
+  EOL = "\0"
+  # TWS_MAX is TWSMAX (transmitted from the TWS) minus the first digit (1)
+  # Anything bigger then TWS_MAX is considered as nil (in read_decimal @ messages/incomming/abstract_message.rb)
+  TWS_MAX = 79769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 
+  TWSMAX = 179769313486231570000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000.0 
+  
+
+  # Enumeration of bar size types for convenience.
+  # Bar sizes less than 30 seconds do not work for some securities.
+  BAR_SIZES = {'1 sec' => :sec1,
+               '5 secs' => :sec5,
+               '15 secs' =>:sec15,
+               '30 secs' =>:sec30,
+               '1 min' => :min1,
+               '2 mins' => :min2,
+               '3 mins' => :min3,
+               '5 mins' => :min5,
+               '15 mins' =>:min15,
+               '30 mins' =>:min30,
+               '1 hour' =>:hour1,
+               '1 day' => :day1
+  }.freeze
+
+  # Enumeration of data types.
+  # Determines the nature of data being extracted. Valid values:
+  DATA_TYPES = {'TRADES' => :trades,
+                'MIDPOINT' => :midpoint,
+                'BID' => :bid,
+                'ASK' => :ask,
+                'BID_ASK' => :bid_ask,
+                'HISTORICAL_VOLATILITY' => :historical_volatility,
+                'OPTION_IMPLIED_VOLATILITY' => :option_implied_volatility,
+                'OPTION_VOLUME' => :option_volume,
+                'OPTION_OPEN_INTEREST' => :option_open_interest
+  }.freeze
+
+  ### These values are typically received from TWS in incoming messages
+
+  # Tick types as received in TickPrice and TickSize messages (enumeration)
+  TICK_TYPES = {
+      # int id => :Description #  Corresponding API Event/Function/Method
+      0 => :bid_size, #               tickSize()
+      1 => :bid_price, #              tickPrice()
+      2 => :ask_price, #              tickPrice()
+      3 => :ask_size, #               tickSize()
+      4 => :last_price, #             tickPrice()
+      5 => :last_size, #              tickSize()
+      6 => :high, #                   tickPrice()
+      7 => :low, #                    tickPrice()
+      8 => :volume, #                 tickSize()
+      9 => :close_price, #            tickPrice()
+      10 => :bid_option, #            tickOptionComputation() See Note 1 below
+      11 => :ask_option, #            tickOptionComputation() See => :Note 1 below
+      12 => :last_option, #           tickOptionComputation()  See Note 1 below
+      13 => :model_option, #          tickOptionComputation() See Note 1 below
+      14 => :open_tick, #             tickPrice()
+      15 => :low_13_week, #           tickPrice()
+      16 => :high_13_week, #          tickPrice()
+      17 => :low_26_week, #           tickPrice()
+      18 => :high_26_week, #          tickPrice()
+      19 => :low_52_week, #           tickPrice()
+      20 => :high_52_week, #          tickPrice()
+      21 => :avg_volume, #            tickSize()
+      22 => :open_interest, #         tickSize()
+      23 => :option_historical_vol, # tickGeneric()
+      24 => :option_implied_vol, #    tickGeneric()
+      25 => :option_bid_exch, #   not USED
+      26 => :option_ask_exch, #   not USED
+      27 => :option_call_open_interest, # tickSize()
+      28 => :option_put_open_interest, #  tickSize()
+      29 => :option_call_volume, #        tickSize()
+      30 => :option_put_volume, #         tickSize()
+      31 => :index_future_premium, #      tickGeneric()
+      32 => :bid_exch, #                  tickString()
+      33 => :ask_exch, #                  tickString()
+      34 => :auction_volume, #    not USED
+      35 => :auction_price, #     not USED
+      36 => :auction_imbalance, # not USED
+      37 => :mark_price, #              tickPrice()
+      38 => :bid_efp_computation, #     tickEFP()
+      39 => :ask_efp_computation, #     tickEFP()
+      40 => :last_efp_computation, #    tickEFP()
+      41 => :open_efp_computation, #    tickEFP()
+      42 => :high_efp_computation, #    tickEFP()
+      43 => :low_efp_computation, #     tickEFP()
+      44 => :close_efp_computation, #   tickEFP()
+      45 => :last_timestamp, #          tickString()
+      46 => :shortable, #               tickGeneric()
+      47 => :fundamental_ratios, #      tickString()
+      48 => :rt_volume, #               tickGeneric()
+      49 => :halted, #           see Note 2 below.
+      50 => :bid_yield, #               tickPrice() See Note 3 below
+      51 => :ask_yield, #               tickPrice() See Note 3 below
+      52 => :last_yield, #              tickPrice() See Note 3 below
+      53 => :cust_option_computation, # tickOptionComputation()
+      54 => :trade_count, #             tickGeneric()
+      55 => :trade_rate, #              tickGeneric()
+      56 => :volume_rate, #             tickGeneric()
+      57 => :last_rth_trade, #
+		  58 => :rt_historical_vol,
+      59 => :ib_dividends,
+      60 => :bond_factor_multiplier,
+      61 => :regulatory_imbalance,
+      62 => :news_tick,
+      63 => :short_term_volume_3_min,
+      64 => :short_term_volume_5_min,
+      65 => :short_term_volume_10_min,
+      66 => :delayed_bid,
+      67 => :delayed_ask,
+      68 => :delayed_last,
+      69 => :delayed_bid_size,
+      70 => :delayed_ask_size,
+      71 => :delayed_last_size,
+      72 => :delayed_high,
+      73 => :delayed_low,
+      74 => :delayed_volume,
+      75 => :delayed_close,
+      76 => :delayed_open,
+      77 => :rt_trd_volume,
+      78 => :creditman_mark_price,
+      79 => :creditman_slow_mark_price,
+      80 => :delayed_bid_option,
+      81 => :delayed_ask_option,
+      82 => :delayed_last_option,
+      83 => :delayed_model_option,
+      84 => :last_exch,
+      85 => :last_reg_time,
+      86 => :futures_open_interest,
+      87 => :avg_opt_volume,
+      88 => :not_set,
+			105 => :average_option_volume   #(for Stocks) tickGeneric()
+
+	
+      #   Note 1: Tick types BID_OPTION, ASK_OPTION, LAST_OPTION, and MODEL_OPTION return
+      #           all Greeks (delta, gamma, vega, theta), the underlying price and the
+      #           stock and option reference price when requested.
+      #           MODEL_OPTION also returns model implied volatility.
+      #   Note 2: When trading is halted for a contract, TWS receives a special tick:
+      #           haltedLast=1. When trading is resumed, TWS receives haltedLast=0.
+      #           A tick type, HALTED, tick ID= 49, is now available in regular market
+      #           data via the API to indicate this halted state. Possible values for
+      #           this new tick type are: 0 = Not halted, 1 = Halted.
+      #   Note 3: Applies to bond contracts only.
+  }
+
+  # Financial Advisor types (FaMsgTypeName)
+  FA_TYPES = {
+      1 => :groups,
+      2 => :profiles,
+      3 => :aliases}.freeze
+
+  # Received in new MarketDataType (58 incoming) message
+  MARKET_DATA_TYPES = {
+      0 => :unknown,
+      1 => :real_time,
+      2 => :frozen,
+			3 => :delayed,
+			4 => :frozen_delayed }.freeze
+
+  # Market depth messages contain these "operation" codes to tell you what to do with the data.
+  # See also http://www.interactivebrokers.com/php/apiUsersGuide/apiguide/java/updatemktdepth.htm
+  MARKET_DEPTH_OPERATIONS = {
+      0 => :insert, # New order, insert into the row identified by :position
+      1 => :update, # Update the existing order at the row identified by :position
+      2 => :delete # Delete the existing order at the row identified by :position
+  }.freeze
+
+  MARKET_DEPTH_SIDES = {
+      0 => :ask,
+      1 => :bid
+  }.freeze
+
+  ORDER_TYPES =
+      {'LMT' => :limit, #                  Limit Order
+       'LIT' => :limit_if_touched, #       Limit if Touched
+       'LOC' => :limit_on_close, #         Limit-on-Close      LMTCLS ?
+       'LOO' => :limit_on_open, #          Limit-on-Open
+       'MKT' => :market, #                 Market
+       'MIT' => :market_if_touched, #      Market-if-Touched
+       'MOC' => :market_on_close, #        Market-on-Close     MKTCLSL ?
+       'MOO' => :market_on_open, #         Market-on-Open
+       'MTL' => :market_to_limit, #        Market-to-Limit
+       'MKT PRT' => :market_protected, #   Market with Protection
+       'QUOTE' => :request_for_quote, #    Request for Quote
+       'STP' => :stop, #                   Stop
+       'STP LMT' => :stop_limit, #         Stop Limit
+       'STP PRT' => :stop_protected, #	   Stop with Protection
+       'TRAIL' => :trailing_stop, #        Trailing Stop
+       'TRAIL LIMIT' => :trailing_limit, # Trailing Stop Limit
+       'TRAIL LIT' => :trailing_limit_if_touched, #  Trailing Limit if Touched
+       'TRAIL MIT' => :trailing_market_if_touched, # Trailing Market If Touched
+       'REL' => :relative, #               Relative
+       'BOX TOP' => :box_top, #            Box Top
+       'PEG MKT' => :pegged_to_market, # Pegged-to-Market
+       'PEG STK' => :pegged_to_market, #   Pegged-to-Stock
+       'PEG MID' => :pegged_to_midpoint, # Pegged-to-Midpoint
+       'PEG BENCH' => :pegged_to_benchmark, # Pegged-to-Benmchmark # Vers. 102
+       'VWAP' => :vwap, #                  VWAP-Guaranted
+       'OCA' => :one_cancels_all, #        One-Cancels-All
+       'VOL' => :volatility, #             Volatility
+       'SCALE' => :scale, #                Scale
+       'NONE' => :none, # Used to indicate no hedge in :delta_neutral_order_type
+       'None' => :none, # Used to indicate no hedge in :delta_neutral_order_type
+      }.freeze
+  # Valid security types (sec_type attribute of IB::Contract)
+  SECURITY_TYPES =
+    {	'BAG' =>  :bag,
+       'BOND' =>  :bond,
+       'CASH' =>  :forex,
+       'CMDTY'=>  :commodity,
+       'CFD'  =>  :cfd,
+       'FUT'  =>  :future,
+       'CONTFUT' => :continous_future,
+       'FUT+CONTFUT' => :all_futures,
+       'FOP'  =>  :futures_option,
+       'FUND' =>  :fund, # ETF?
+       'IND'  =>  :index,
+       'NEWS'  => :news,
+       'OPT'  =>  :option,
+       'IOPT' =>  :dutch_option,
+       'STK'  =>  :stock,
+       'WAR'  =>  :warrant,
+	     'ICU' =>   :icu,
+			 'ICS' =>  :ics, 
+	     'BILL' =>  :bill,
+	     'BSK'  =>  :basket,
+			 'FWD' =>   :forward,
+			 'FIXED' => :fixed }.freeze
+
+  # Obtain symbolic value from given property code:
+  # VALUES[:side]['B'] -> :buy
+  VALUES = {
+      :sec_type => SECURITY_TYPES,
+      :order_type => ORDER_TYPES,
+      :delta_neutral_order_type => ORDER_TYPES,
+
+      :origin => {0 => :customer, 1 => :firm},
+      :volatility_type => {1 => :daily, 2 => :annual},
+      :reference_price_type => {1 => :average, 2 => :bid_or_ask},
+
+      # This property encodes differently for ComboLeg and Order objects,
+      # we use ComboLeg codes and transcode for Order codes as needed
+      :open_close =>
+          {0 => :same, # Default for Legs, same as the parent (combo) security.
+           1 => :open, #  Open. For Legs, this value is only used by institutions.
+           2 => :close, # Close. For Legs, this value is only used by institutions.
+           3 => :unknown}, # WTF
+
+      :right =>
+          {'' => :none, # Not an option
+           'P' => :put,
+           'C' => :call},
+
+      :side => # AKA action
+          {'B' => :buy, # or BOT
+           'S' => :sell, # or SLD
+           'T' => :short, # short
+           'X' => :short_exempt # Short Sale Exempt action. This allows some orders
+           # to be exempt from the SEC recent changes to Regulation SHO, which
+           # eliminated the old uptick rule and replaced it with a new "circuit breaker"
+           # rule, and allows some orders to be exempt from the new rule.
+          },
+
+      :short_sale_slot =>
+          {0 => :default, #      The only valid option for retail customers
+           1 => :broker, #       Shares are at your clearing broker, institutions
+           2 => :third_party}, # Shares will be delivered from elsewhere, institutions
+
+      :oca_type =>
+          {0 => :none, # Not a member of OCA group
+           1 => :cancel_with_block, # Cancel all remaining orders with block
+           2 => :reduce_with_block, # Remaining orders are reduced in size with block
+           3 => :reduce_no_block}, # Remaining orders are reduced in size with no block
+
+      :auction_strategy =>
+          {0 => :none, # Not a BOX order
+           1 => :match,
+           2 => :improvement,
+           3 => :transparent},
+
+      :trigger_method =>
+          {0 => :default, # "double bid/ask" used for OTC/US options, "last" otherswise.
+           1 => :double_bid_ask, # stops are triggered by 2 consecutive bid or ask prices.
+           2 => :last, # stops are triggered based on the last price.
+           3 => :double_last,
+           4 => :bid_ask, # bid >= trigger price for buy orders, ask <= trigger for sell orders
+           7 => :last_or_bid_ask, # bid OR last price >= trigger price for buy orders
+           8 => :mid_point}, # midpoint >= trigger price for buy orders and the
+      #      spread between the bid and ask must be less than 0.1% of the midpoint
+
+      :hedge_type =>
+          {'D' => :delta, # parent order is an option and the child order is a stock
+           'B' => :beta, # offset market risk by entering into a position with
+           #               another contract based on the system or user-defined beta
+           'F' => :forex, # offset risk with currency different from your base currency
+           'P' => :pair}, # trade a mis-valued pair of contracts and provide the
+      #                     ratio between the parent and hedging child order
+
+      :clearing_intent =>
+          {'' => :none,
+           'IB' => :ib,
+           'AWAY' => :away,
+           'PTA' => :post_trade_allocation},
+
+      :delta_neutral_clearing_intent =>
+          {'' => :none,
+           'IB' => :ib,
+           'AWAY' => :away,
+           'PTA' => :post_trade_allocation},
+
+      :tif =>
+          {'DAY' => :day,
+           'GAT' => :good_after_time,
+           'GTD' => :good_till_date,
+           'GTC' => :good_till_cancelled,
+           'IOC' => :immediate_or_cancel,
+	   'OPG' => :opening_price, 
+	   'AUC' => :at_auction},
+
+      :rule_80a =>
+          {'I' => :individual,
+           'A' => :agency,
+           'W' => :agent_other_member,
+           'J' => :individual_ptia,
+           'U' => :agency_ptia,
+           'M' => :agent_other_member_ptia,
+           'K' => :individual_pt,
+           'Y' => :agency_pt,
+           'N' => :agent_other_member_pt},
+
+      :opt? => # TODO: unknown Order property, like OPT_BROKER_DEALER... in Order.java
+          {'?' => :unknown,
+           'b' => :broker_dealer,
+           'c' => :customer,
+           'f' => :firm,
+           'm' => :isemm,
+           'n' => :farmm,
+           'y' => :specialist},
+# conditions
+		   :conjunction_connection => { 'o' =>  :or, 'a' => :and },
+			 :operator => { 1 => '>=' , 0 => '<=' }
+ 
+  }.freeze
+
+  # Obtain property code from given symbolic value:
+  # CODES[:side][:buy] -> 'B'
+  CODES = Hash[VALUES.map { |property, hash| [property, hash.invert] }].freeze
+
+  # Most common property processors
+  PROPS = {:side =>
+               {:set => proc { |val| # BUY(BOT)/SELL(SLD)/SSHORT/SSHORTX
+                 self[:side] = case val.to_s.upcase
+                                 when /SHORT.*X|\AX\z/
+                                   'X'
+                                 when /SHORT|\AT\z/
+                                   'T'
+                                 when /\AB/
+                                   'B'
+                                 when /\AS/
+                                   'S'
+                               end },
+                :validate =>
+                    {:format =>
+                         {:with => /\Abuy\z|\Asell\z|\Ashort\z|\Ashort_exempt\z/,
+                          :message => "should be buy/sell/short"}
+                    }
+               },
+
+           :open_close =>
+               {:set => proc { |val|
+                 self[:open_close] = case val.to_s.upcase[0..0]
+                                       when 'S', '0' # SAME
+                                         0
+                                       when 'O', '1' # OPEN
+                                         1
+                                       when 'C', '2' # CLOSE
+                                         2
+                                       when 'U', '3' # Unknown
+                                         3
+                                     end
+               },
+                :validate =>
+                    {:format =>
+                         {:with => /\Asame\z|\Aopen\z|\Aclose\z|\Aunknown\z/,
+                          :message => "should be same/open/close/unknown"}
+                    },
+               }
+  }.freeze
+
+end # module IB