├── .gitignore ├── LICENSE.txt ├── README.md ├── __init__.py ├── codegen ├── DTCProtocol.h ├── __init__.py ├── code_generator.py └── templates │ ├── enum_template.jinja2 │ ├── message_type_template.jinja2 │ └── util_template.jinja2 ├── dtc ├── __init__.py ├── enums │ ├── __init__.py │ ├── at_bid_or_ask_enum.py │ ├── at_bid_or_ask_enum8.py │ ├── buy_sell_enum.py │ ├── encoding_enum.py │ ├── final_update_in_batch_enum.py │ ├── historical_data_interval_enum.py │ ├── historical_price_data_reject_reason_code_enum.py │ ├── logon_status_enum.py │ ├── market_data_feed_status_enum.py │ ├── market_depth_update_type_enum.py │ ├── message_supported_enum.py │ ├── message_types.py │ ├── open_close_trade_enum.py │ ├── order_status_enum.py │ ├── order_type_enum.py │ ├── order_update_reason_enum.py │ ├── partial_fill_handling_enum.py │ ├── price_display_format_enum.py │ ├── put_call_enum.py │ ├── request_action_enum.py │ ├── search_type_enum.py │ ├── security_type_enum.py │ ├── string_lengths.py │ ├── time_in_force_enum.py │ ├── trade_mode_enum.py │ ├── trading_status_enum.py │ └── unbundled_trade_indicator_enum.py ├── message_types │ ├── __init__.py │ ├── account_balance_adjustment.py │ ├── account_balance_adjustment_complete.py │ ├── account_balance_adjustment_reject.py │ ├── account_balance_reject.py │ ├── account_balance_request.py │ ├── account_balance_update.py │ ├── alert_message.py │ ├── cancel_order.py │ ├── cancel_replace_order.py │ ├── cancel_replace_order_int.py │ ├── current_positions_reject.py │ ├── current_positions_request.py │ ├── encoding_request.py │ ├── encoding_response.py │ ├── exchange_list_request.py │ ├── exchange_list_response.py │ ├── general_log_message.py │ ├── heartbeat.py │ ├── historical_account_balance_response.py │ ├── historical_account_balances_reject.py │ ├── historical_account_balances_request.py │ ├── historical_order_fill_response.py │ ├── historical_order_fills_reject.py │ ├── historical_order_fills_request.py │ ├── historical_price_data_record_response.py │ ├── historical_price_data_record_response_int.py │ ├── historical_price_data_reject.py │ ├── historical_price_data_request.py │ ├── historical_price_data_response_header.py │ ├── historical_price_data_response_trailer.py │ ├── historical_price_data_tick_record_response.py │ ├── historical_price_data_tick_record_response_int.py │ ├── journal_entries_reject.py │ ├── journal_entries_request.py │ ├── journal_entry_add.py │ ├── journal_entry_response.py │ ├── logoff.py │ ├── logon_request.py │ ├── logon_response.py │ ├── market_data_feed_status.py │ ├── market_data_feed_symbol_status.py │ ├── market_data_reject.py │ ├── market_data_request.py │ ├── market_data_snapshot.py │ ├── market_data_snapshot_int.py │ ├── market_data_update_bid_ask.py │ ├── market_data_update_bid_ask_compact.py │ ├── market_data_update_bid_ask_float_with_milliseconds.py │ ├── market_data_update_bid_ask_int.py │ ├── market_data_update_last_trade_snapshot.py │ ├── market_data_update_open_interest.py │ ├── market_data_update_session_high.py │ ├── market_data_update_session_high_int.py │ ├── market_data_update_session_low.py │ ├── market_data_update_session_low_int.py │ ├── market_data_update_session_num_trades.py │ ├── market_data_update_session_open.py │ ├── market_data_update_session_open_int.py │ ├── market_data_update_session_settlement.py │ ├── market_data_update_session_settlement_int.py │ ├── market_data_update_session_volume.py │ ├── market_data_update_trade.py │ ├── market_data_update_trade_compact.py │ ├── market_data_update_trade_int.py │ ├── market_data_update_trade_no_timestamp.py │ ├── market_data_update_trade_with_unbundled_indicator.py │ ├── market_data_update_trading_session_date.py │ ├── market_depth_reject.py │ ├── market_depth_request.py │ ├── market_depth_snapshot_level.py │ ├── market_depth_snapshot_level_float.py │ ├── market_depth_snapshot_level_int.py │ ├── market_depth_update_level.py │ ├── market_depth_update_level_float_with_milliseconds.py │ ├── market_depth_update_level_int.py │ ├── market_depth_update_level_no_timestamp.py │ ├── open_orders_reject.py │ ├── open_orders_request.py │ ├── order_update.py │ ├── position_update.py │ ├── security_definition_for_symbol_request.py │ ├── security_definition_reject.py │ ├── security_definition_response.py │ ├── submit_flatten_position_order.py │ ├── submit_new_oco_order.py │ ├── submit_new_oco_order_int.py │ ├── submit_new_single_order.py │ ├── submit_new_single_order_int.py │ ├── symbol_search_request.py │ ├── symbols_for_exchange_request.py │ ├── symbols_for_underlying_request.py │ ├── trade_account_response.py │ ├── trade_accounts_request.py │ ├── trading_symbol_status.py │ ├── underlying_symbols_for_exchange_request.py │ └── user_message.py └── util │ ├── __init__.py │ └── message_util.py ├── dtc_client ├── __init__.py ├── data_message_types.py ├── dtc_client.py └── enums.py ├── example_client.py ├── lib ├── __init__.py ├── base_message_type.py ├── constants.py ├── error.py ├── symbol_util.py └── util.py └── rest ├── __init__.py ├── api.py ├── method.py └── rest_server.py /.gitignore: -------------------------------------------------------------------------------- 1 | .idea/ 2 | **/__pycache__/ -------------------------------------------------------------------------------- /__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/__init__.py -------------------------------------------------------------------------------- /codegen/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/codegen/__init__.py -------------------------------------------------------------------------------- /codegen/templates/enum_template.jinja2: -------------------------------------------------------------------------------- 1 | 2 | class {{class_name}}: 3 | {% for var in values %} {{ var.name }} = {{ var.value }}{{ "\n" }}{% endfor %} 4 | -------------------------------------------------------------------------------- /codegen/templates/message_type_template.jinja2: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class {{class_name}}(BaseMessageType): 7 | def __init__(self{% for var in values %}, 8 | {{ var._name }}=None{% endfor %}): 9 | self.Type = MessageTypes.{{class_name_snake}} 10 | {% for var in values %} self.{{ var.name }} = {{ var._name }}{{ "\n" }}{% endfor %} 11 | @staticmethod 12 | def from_message_short(message_obj): 13 | packet = message_obj.get('F') 14 | return {{class_name}}( 15 | {% for var in values %} {{ var._name }}=packet[{{ loop.index - 1 }}]{% if not loop.last %}{{ ",\n" }}{% endif %}{% endfor %} 16 | ) 17 | 18 | @staticmethod 19 | def from_message_long(message_obj): 20 | return {{class_name}}( 21 | {% for var in values %} {{ var._name }}=message_obj.get('{{ var.name }}'){% if not loop.last %}{{ ",\n" }}{% endif %}{% endfor %} 22 | ) 23 | 24 | @staticmethod 25 | def from_message(message_obj): 26 | if 'F' in message_obj: 27 | return {{class_name}}.from_message_short(message_obj) 28 | else: 29 | return {{class_name}}.from_message_long(message_obj) 30 | 31 | @staticmethod 32 | def get_message_type_name(): 33 | return "{{class_name}}" 34 | 35 | -------------------------------------------------------------------------------- /codegen/templates/util_template.jinja2: -------------------------------------------------------------------------------- 1 | import json 2 | import logging 3 | from dtc.enums.message_types import MessageTypes 4 | 5 | {% for _class in classes %}from dtc.message_types.{{ _class._name|lower }} import {{ _class.__name }} 6 | {% endfor %} 7 | TYPE = 'Type' 8 | 9 | 10 | class MessageUtil: 11 | def __init__(self): 12 | pass 13 | 14 | @staticmethod 15 | def parse_incoming_message(message_text): 16 | response = None 17 | message_obj = json.loads(message_text) 18 | 19 | {% for _class in classes %} {% if not loop.first %}el{% endif %}if message_obj[TYPE] == MessageTypes.{{ _class._name|upper }}: 20 | response = {{ _class.__name }}.from_message(message_obj) 21 | {% endfor %} 22 | return response 23 | 24 | -------------------------------------------------------------------------------- /dtc/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/dtc/__init__.py -------------------------------------------------------------------------------- /dtc/enums/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/dtc/enums/__init__.py -------------------------------------------------------------------------------- /dtc/enums/at_bid_or_ask_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class AtBidOrAskEnum: 3 | BID_ASK_UNSET = 0 4 | AT_BID = 1 5 | AT_ASK = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/at_bid_or_ask_enum8.py: -------------------------------------------------------------------------------- 1 | 2 | class AtBidOrAskEnum8: 3 | BID_ASK_UNSET_8 = 0 4 | AT_BID_8 = 1 5 | AT_ASK_8 = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/buy_sell_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class BuySellEnum: 3 | BUY_SELL_UNSET = 0 4 | BUY = 1 5 | SELL = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/encoding_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class EncodingEnum: 3 | BINARY_ENCODING = 0 4 | BINARY_WITH_VARIABLE_LENGTH_STRINGS = 1 5 | JSON_ENCODING = 2 6 | JSON_COMPACT_ENCODING = 3 7 | PROTOCOL_BUFFERS = 4 8 | -------------------------------------------------------------------------------- /dtc/enums/final_update_in_batch_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class FinalUpdateInBatchEnum: 3 | FINAL_UPDATE_UNSET = 0 4 | FINAL_UPDATE_TRUE = 1 5 | FINAL_UPDATE_FALSE = 2 6 | FINAL_UPDATE_BEGIN_BATCH = 3 7 | -------------------------------------------------------------------------------- /dtc/enums/historical_data_interval_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class HistoricalDataIntervalEnum: 3 | INTERVAL_TICK = 0 4 | INTERVAL_1_SECOND = 1 5 | INTERVAL_2_SECONDS = 2 6 | INTERVAL_4_SECONDS = 4 7 | INTERVAL_5_SECONDS = 5 8 | INTERVAL_10_SECONDS = 10 9 | INTERVAL_30_SECONDS = 30 10 | INTERVAL_1_MINUTE = 60 11 | INTERVAL_5_MINUTE = 300 12 | INTERVAL_10_MINUTE = 600 13 | INTERVAL_15_MINUTE = 900 14 | INTERVAL_30_MINUTE = 1800 15 | INTERVAL_1_HOUR = 3600 16 | INTERVAL_2_HOURS = 7200 17 | INTERVAL_1_DAY = 86400 18 | INTERVAL_1_WEEK = 604800 19 | -------------------------------------------------------------------------------- /dtc/enums/historical_price_data_reject_reason_code_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class HistoricalPriceDataRejectReasonCodeEnum: 3 | HPDR_UNSET = 0 4 | HPDR_UNABLE_TO_SERVE_DATA_RETRY_IN_SPECIFIED_SECONDS = 1 5 | HPDR_UNABLE_TO_SERVE_DATA_DO_NOT_RETRY = 2 6 | HPDR_DATA_REQUEST_OUTSIDE_BOUNDS_OF_AVAILABLE_DATA = 3 7 | HPDR_GENERAL_REJECT_ERROR = 4 8 | -------------------------------------------------------------------------------- /dtc/enums/logon_status_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class LogonStatusEnum: 3 | LOGON_SUCCESS = 1 4 | LOGON_ERROR = 2 5 | LOGON_ERROR_NO_RECONNECT = 3 6 | LOGON_RECONNECT_NEW_ADDRESS = 4 7 | -------------------------------------------------------------------------------- /dtc/enums/market_data_feed_status_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class MarketDataFeedStatusEnum: 3 | MARKET_DATA_FEED_STATUS_UNSET = 0 4 | MARKET_DATA_FEED_UNAVAILABLE = 1 5 | MARKET_DATA_FEED_AVAILABLE = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/market_depth_update_type_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class MarketDepthUpdateTypeEnum: 3 | MARKET_DEPTH_UNSET = 0 4 | MARKET_DEPTH_INSERT_UPDATE_LEVEL = 1 5 | MARKET_DEPTH_DELETE_LEVEL = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/message_supported_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class MessageSupportedEnum: 3 | MESSAGE_UNSUPPORTED = 0 4 | MESSAGE_SUPPORTED = 1 5 | -------------------------------------------------------------------------------- /dtc/enums/message_types.py: -------------------------------------------------------------------------------- 1 | 2 | class MessageTypes: 3 | LOGON_REQUEST = 1 4 | LOGON_RESPONSE = 2 5 | HEARTBEAT = 3 6 | LOGOFF = 5 7 | ENCODING_REQUEST = 6 8 | ENCODING_RESPONSE = 7 9 | MARKET_DATA_REQUEST = 101 10 | MARKET_DATA_REJECT = 103 11 | MARKET_DATA_SNAPSHOT = 104 12 | MARKET_DATA_SNAPSHOT_INT = 125 13 | MARKET_DATA_UPDATE_TRADE = 107 14 | MARKET_DATA_UPDATE_TRADE_COMPACT = 112 15 | MARKET_DATA_UPDATE_TRADE_INT = 126 16 | MARKET_DATA_UPDATE_LAST_TRADE_SNAPSHOT = 134 17 | MARKET_DATA_UPDATE_TRADE_WITH_UNBUNDLED_INDICATOR = 137 18 | MARKET_DATA_UPDATE_TRADE_NO_TIMESTAMP = 142 19 | MARKET_DATA_UPDATE_BID_ASK = 108 20 | MARKET_DATA_UPDATE_BID_ASK_COMPACT = 117 21 | MARKET_DATA_UPDATE_BID_ASK_INT = 127 22 | MARKET_DATA_UPDATE_BID_ASK_NO_TIMESTAMP = 143 23 | MARKET_DATA_UPDATE_BID_ASK_FLOAT_WITH_MILLISECONDS = 144 24 | MARKET_DATA_UPDATE_SESSION_OPEN = 120 25 | MARKET_DATA_UPDATE_SESSION_OPEN_INT = 128 26 | MARKET_DATA_UPDATE_SESSION_HIGH = 114 27 | MARKET_DATA_UPDATE_SESSION_HIGH_INT = 129 28 | MARKET_DATA_UPDATE_SESSION_LOW = 115 29 | MARKET_DATA_UPDATE_SESSION_LOW_INT = 130 30 | MARKET_DATA_UPDATE_SESSION_VOLUME = 113 31 | MARKET_DATA_UPDATE_OPEN_INTEREST = 124 32 | MARKET_DATA_UPDATE_SESSION_SETTLEMENT = 119 33 | MARKET_DATA_UPDATE_SESSION_SETTLEMENT_INT = 131 34 | MARKET_DATA_UPDATE_SESSION_NUM_TRADES = 135 35 | MARKET_DATA_UPDATE_TRADING_SESSION_DATE = 136 36 | MARKET_DEPTH_REQUEST = 102 37 | MARKET_DEPTH_REJECT = 121 38 | MARKET_DEPTH_SNAPSHOT_LEVEL = 122 39 | MARKET_DEPTH_SNAPSHOT_LEVEL_INT = 132 40 | MARKET_DEPTH_SNAPSHOT_LEVEL_FLOAT = 145 41 | MARKET_DEPTH_UPDATE_LEVEL = 106 42 | MARKET_DEPTH_UPDATE_LEVEL_FLOAT_WITH_MILLISECONDS = 140 43 | MARKET_DEPTH_UPDATE_LEVEL_NO_TIMESTAMP = 141 44 | MARKET_DEPTH_UPDATE_LEVEL_INT = 133 45 | MARKET_DATA_FEED_STATUS = 100 46 | MARKET_DATA_FEED_SYMBOL_STATUS = 116 47 | TRADING_SYMBOL_STATUS = 138 48 | SUBMIT_NEW_SINGLE_ORDER = 208 49 | SUBMIT_NEW_SINGLE_ORDER_INT = 206 50 | SUBMIT_NEW_OCO_ORDER = 201 51 | SUBMIT_NEW_OCO_ORDER_INT = 207 52 | SUBMIT_FLATTEN_POSITION_ORDER = 209 53 | CANCEL_ORDER = 203 54 | CANCEL_REPLACE_ORDER = 204 55 | CANCEL_REPLACE_ORDER_INT = 205 56 | OPEN_ORDERS_REQUEST = 300 57 | OPEN_ORDERS_REJECT = 302 58 | ORDER_UPDATE = 301 59 | HISTORICAL_ORDER_FILLS_REQUEST = 303 60 | HISTORICAL_ORDER_FILLS_REJECT = 308 61 | HISTORICAL_ORDER_FILL_RESPONSE = 304 62 | CURRENT_POSITIONS_REQUEST = 305 63 | CURRENT_POSITIONS_REJECT = 307 64 | POSITION_UPDATE = 306 65 | TRADE_ACCOUNTS_REQUEST = 400 66 | TRADE_ACCOUNT_RESPONSE = 401 67 | EXCHANGE_LIST_REQUEST = 500 68 | EXCHANGE_LIST_RESPONSE = 501 69 | SYMBOLS_FOR_EXCHANGE_REQUEST = 502 70 | UNDERLYING_SYMBOLS_FOR_EXCHANGE_REQUEST = 503 71 | SYMBOLS_FOR_UNDERLYING_REQUEST = 504 72 | SECURITY_DEFINITION_FOR_SYMBOL_REQUEST = 506 73 | SECURITY_DEFINITION_RESPONSE = 507 74 | SYMBOL_SEARCH_REQUEST = 508 75 | SECURITY_DEFINITION_REJECT = 509 76 | ACCOUNT_BALANCE_REQUEST = 601 77 | ACCOUNT_BALANCE_REJECT = 602 78 | ACCOUNT_BALANCE_UPDATE = 600 79 | ACCOUNT_BALANCE_ADJUSTMENT = 607 80 | ACCOUNT_BALANCE_ADJUSTMENT_REJECT = 608 81 | ACCOUNT_BALANCE_ADJUSTMENT_COMPLETE = 609 82 | HISTORICAL_ACCOUNT_BALANCES_REQUEST = 603 83 | HISTORICAL_ACCOUNT_BALANCES_REJECT = 604 84 | HISTORICAL_ACCOUNT_BALANCE_RESPONSE = 606 85 | USER_MESSAGE = 700 86 | GENERAL_LOG_MESSAGE = 701 87 | ALERT_MESSAGE = 702 88 | JOURNAL_ENTRY_ADD = 703 89 | JOURNAL_ENTRIES_REQUEST = 704 90 | JOURNAL_ENTRIES_REJECT = 705 91 | JOURNAL_ENTRY_RESPONSE = 706 92 | HISTORICAL_PRICE_DATA_REQUEST = 800 93 | HISTORICAL_PRICE_DATA_RESPONSE_HEADER = 801 94 | HISTORICAL_PRICE_DATA_REJECT = 802 95 | HISTORICAL_PRICE_DATA_RECORD_RESPONSE = 803 96 | HISTORICAL_PRICE_DATA_TICK_RECORD_RESPONSE = 804 97 | HISTORICAL_PRICE_DATA_RECORD_RESPONSE_INT = 805 98 | HISTORICAL_PRICE_DATA_TICK_RECORD_RESPONSE_INT = 806 99 | HISTORICAL_PRICE_DATA_RESPONSE_TRAILER = 807 100 | -------------------------------------------------------------------------------- /dtc/enums/open_close_trade_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class OpenCloseTradeEnum: 3 | TRADE_UNSET = 0 4 | TRADE_OPEN = 1 5 | TRADE_CLOSE = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/order_status_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class OrderStatusEnum: 3 | ORDER_STATUS_UNSPECIFIED = 0 4 | ORDER_STATUS_ORDER_SENT = 1 5 | ORDER_STATUS_PENDING_OPEN = 2 6 | ORDER_STATUS_PENDING_CHILD = 3 7 | ORDER_STATUS_OPEN = 4 8 | ORDER_STATUS_PENDING_CANCEL_REPLACE = 5 9 | ORDER_STATUS_PENDING_CANCEL = 6 10 | ORDER_STATUS_FILLED = 7 11 | ORDER_STATUS_CANCELED = 8 12 | ORDER_STATUS_REJECTED = 9 13 | ORDER_STATUS_PARTIALLY_FILLED = 10 14 | -------------------------------------------------------------------------------- /dtc/enums/order_type_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class OrderTypeEnum: 3 | ORDER_TYPE_UNSET = 0 4 | ORDER_TYPE_MARKET = 1 5 | ORDER_TYPE_LIMIT = 2 6 | ORDER_TYPE_STOP = 3 7 | ORDER_TYPE_STOP_LIMIT = 4 8 | ORDER_TYPE_MARKET_IF_TOUCHED = 5 9 | ORDER_TYPE_LIMIT_IF_TOUCHED = 6 10 | -------------------------------------------------------------------------------- /dtc/enums/order_update_reason_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class OrderUpdateReasonEnum: 3 | ORDER_UPDATE_REASON_UNSET = 0 4 | OPEN_ORDERS_REQUEST_RESPONSE = 1 5 | NEW_ORDER_ACCEPTED = 2 6 | GENERAL_ORDER_UPDATE = 3 7 | ORDER_FILLED = 4 8 | ORDER_FILLED_PARTIALLY = 5 9 | ORDER_CANCELED = 6 10 | ORDER_CANCEL_REPLACE_COMPLETE = 7 11 | NEW_ORDER_REJECTED = 8 12 | ORDER_CANCEL_REJECTED = 9 13 | ORDER_CANCEL_REPLACE_REJECTED = 10 14 | -------------------------------------------------------------------------------- /dtc/enums/partial_fill_handling_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class PartialFillHandlingEnum: 3 | PARTIAL_FILL_UNSET = 0 4 | PARTIAL_FILL_HANDLING_REDUCE_QUANTITY = 1 5 | PARTIAL_FILL_HANDLING_IMMEDIATE_CANCEL = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/price_display_format_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class PriceDisplayFormatEnum: 3 | PRICE_DISPLAY_FORMAT_UNSET = - 1 4 | PRICE_DISPLAY_FORMAT_DECIMAL_0 = 0 5 | PRICE_DISPLAY_FORMAT_DECIMAL_1 = 1 6 | PRICE_DISPLAY_FORMAT_DECIMAL_2 = 2 7 | PRICE_DISPLAY_FORMAT_DECIMAL_3 = 3 8 | PRICE_DISPLAY_FORMAT_DECIMAL_4 = 4 9 | PRICE_DISPLAY_FORMAT_DECIMAL_5 = 5 10 | PRICE_DISPLAY_FORMAT_DECIMAL_6 = 6 11 | PRICE_DISPLAY_FORMAT_DECIMAL_7 = 7 12 | PRICE_DISPLAY_FORMAT_DECIMAL_8 = 8 13 | PRICE_DISPLAY_FORMAT_DECIMAL_9 = 9 14 | PRICE_DISPLAY_FORMAT_DENOMINATOR_256 = 356 15 | PRICE_DISPLAY_FORMAT_DENOMINATOR_128 = 228 16 | PRICE_DISPLAY_FORMAT_DENOMINATOR_64 = 164 17 | PRICE_DISPLAY_FORMAT_DENOMINATOR_32_EIGHTHS = 140 18 | PRICE_DISPLAY_FORMAT_DENOMINATOR_32_QUARTERS = 136 19 | PRICE_DISPLAY_FORMAT_DENOMINATOR_32_HALVES = 134 20 | PRICE_DISPLAY_FORMAT_DENOMINATOR_32 = 132 21 | PRICE_DISPLAY_FORMAT_DENOMINATOR_16 = 116 22 | PRICE_DISPLAY_FORMAT_DENOMINATOR_8 = 108 23 | PRICE_DISPLAY_FORMAT_DENOMINATOR_4 = 104 24 | PRICE_DISPLAY_FORMAT_DENOMINATOR_2 = 102 25 | -------------------------------------------------------------------------------- /dtc/enums/put_call_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class PutCallEnum: 3 | PC_UNSET = 0 4 | PC_CALL = 1 5 | PC_PUT = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/request_action_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class RequestActionEnum: 3 | SUBSCRIBE = 1 4 | UNSUBSCRIBE = 2 5 | SNAPSHOT = 3 6 | SNAPSHOT_WITH_INTERVAL_UPDATES = 4 7 | -------------------------------------------------------------------------------- /dtc/enums/search_type_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class SearchTypeEnum: 3 | SEARCH_TYPE_UNSET = 0 4 | SEARCH_TYPE_BY_SYMBOL = 1 5 | SEARCH_TYPE_BY_DESCRIPTION = 2 6 | -------------------------------------------------------------------------------- /dtc/enums/security_type_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class SecurityTypeEnum: 3 | SECURITY_TYPE_UNSET = 0 4 | SECURITY_TYPE_FUTURES = 1 5 | SECURITY_TYPE_STOCK = 2 6 | SECURITY_TYPE_FOREX = 3 7 | SECURITY_TYPE_INDEX = 4 8 | SECURITY_TYPE_FUTURES_STRATEGY = 5 9 | SECURITY_TYPE_FUTURES_OPTION = 7 10 | SECURITY_TYPE_STOCK_OPTION = 6 11 | SECURITY_TYPE_INDEX_OPTION = 8 12 | SECURITY_TYPE_BOND = 9 13 | SECURITY_TYPE_MUTUAL_FUND = 10 14 | -------------------------------------------------------------------------------- /dtc/enums/string_lengths.py: -------------------------------------------------------------------------------- 1 | 2 | class StringLengths: 3 | CURRENT_VERSION = 8 4 | USERNAME_PASSWORD_LENGTH = 32 5 | SYMBOL_EXCHANGE_DELIMITER_LENGTH = 4 6 | SYMBOL_LENGTH = 64 7 | EXCHANGE_LENGTH = 16 8 | UNDERLYING_SYMBOL_LENGTH = 32 9 | SYMBOL_DESCRIPTION_LENGTH = 64 10 | EXCHANGE_DESCRIPTION_LENGTH = 48 11 | ORDER_ID_LENGTH = 32 12 | TRADE_ACCOUNT_LENGTH = 32 13 | TEXT_DESCRIPTION_LENGTH = 96 14 | TEXT_MESSAGE_LENGTH = 256 15 | ORDER_FREE_FORM_TEXT_LENGTH = 48 16 | CLIENT_SERVER_NAME_LENGTH = 48 17 | GENERAL_IDENTIFIER_LENGTH = 64 18 | CURRENCY_CODE_LENGTH = 8 19 | ORDER_FILL_EXECUTION_LENGTH = 64 20 | -------------------------------------------------------------------------------- /dtc/enums/time_in_force_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class TimeInForceEnum: 3 | TIF_UNSET = 0 4 | TIF_DAY = 1 5 | TIF_GOOD_TILL_CANCELED = 2 6 | TIF_GOOD_TILL_DATE_TIME = 3 7 | TIF_IMMEDIATE_OR_CANCEL = 4 8 | TIF_ALL_OR_NONE = 5 9 | TIF_FILL_OR_KILL = 6 10 | -------------------------------------------------------------------------------- /dtc/enums/trade_mode_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class TradeModeEnum: 3 | TRADE_MODE_UNSET = 0 4 | TRADE_MODE_DEMO = 1 5 | TRADE_MODE_SIMULATED = 2 6 | TRADE_MODE_LIVE = 3 7 | -------------------------------------------------------------------------------- /dtc/enums/trading_status_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class TradingStatusEnum: 3 | TRADING_STATUS_UNKNOWN = 0 4 | TRADING_STATUS_PRE_OPEN = 1 5 | TRADING_STATUS_OPEN = 2 6 | TRADING_STATUS_CLOSE = 3 7 | TRADING_STATUS_TRADING_HALT = 4 8 | -------------------------------------------------------------------------------- /dtc/enums/unbundled_trade_indicator_enum.py: -------------------------------------------------------------------------------- 1 | 2 | class UnbundledTradeIndicatorEnum: 3 | UNBUNDLED_TRADE_NONE = 0 4 | FIRST_SUB_TRADE_OF_UNBUNDLED_TRADE = 1 5 | LAST_SUB_TRADE_OF_UNBUNDLED_TRADE = 2 6 | -------------------------------------------------------------------------------- /dtc/message_types/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/dtc/message_types/__init__.py -------------------------------------------------------------------------------- /dtc/message_types/account_balance_adjustment.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AccountBalanceAdjustment(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | trade_account=None, 10 | credit_amount=None, 11 | debit_amount=None, 12 | currency=None, 13 | reason=None): 14 | self.Type = MessageTypes.ACCOUNT_BALANCE_ADJUSTMENT 15 | self.RequestID = request_id 16 | self.TradeAccount = trade_account 17 | self.CreditAmount = credit_amount 18 | self.DebitAmount = debit_amount 19 | self.Currency = currency 20 | self.Reason = reason 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return AccountBalanceAdjustment( 26 | request_id=packet[0], 27 | trade_account=packet[1], 28 | credit_amount=packet[2], 29 | debit_amount=packet[3], 30 | currency=packet[4], 31 | reason=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return AccountBalanceAdjustment( 37 | request_id=message_obj.get('RequestID'), 38 | trade_account=message_obj.get('TradeAccount'), 39 | credit_amount=message_obj.get('CreditAmount'), 40 | debit_amount=message_obj.get('DebitAmount'), 41 | currency=message_obj.get('Currency'), 42 | reason=message_obj.get('Reason') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return AccountBalanceAdjustment.from_message_short(message_obj) 49 | else: 50 | return AccountBalanceAdjustment.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "AccountBalanceAdjustment" 55 | -------------------------------------------------------------------------------- /dtc/message_types/account_balance_adjustment_complete.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AccountBalanceAdjustmentComplete(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | transaction_id=None): 10 | self.Type = MessageTypes.ACCOUNT_BALANCE_ADJUSTMENT_COMPLETE 11 | self.RequestID = request_id 12 | self.TransactionID = transaction_id 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return AccountBalanceAdjustmentComplete( 18 | request_id=packet[0], 19 | transaction_id=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return AccountBalanceAdjustmentComplete( 25 | request_id=message_obj.get('RequestID'), 26 | transaction_id=message_obj.get('TransactionID') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return AccountBalanceAdjustmentComplete.from_message_short(message_obj) 33 | else: 34 | return AccountBalanceAdjustmentComplete.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "AccountBalanceAdjustmentComplete" 39 | -------------------------------------------------------------------------------- /dtc/message_types/account_balance_adjustment_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AccountBalanceAdjustmentReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.ACCOUNT_BALANCE_ADJUSTMENT_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return AccountBalanceAdjustmentReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return AccountBalanceAdjustmentReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return AccountBalanceAdjustmentReject.from_message_short(message_obj) 33 | else: 34 | return AccountBalanceAdjustmentReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "AccountBalanceAdjustmentReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/account_balance_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AccountBalanceReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.ACCOUNT_BALANCE_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return AccountBalanceReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return AccountBalanceReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return AccountBalanceReject.from_message_short(message_obj) 33 | else: 34 | return AccountBalanceReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "AccountBalanceReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/account_balance_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AccountBalanceRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | trade_account=None): 10 | self.Type = MessageTypes.ACCOUNT_BALANCE_REQUEST 11 | self.RequestID = request_id 12 | self.TradeAccount = trade_account 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return AccountBalanceRequest( 18 | request_id=packet[0], 19 | trade_account=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return AccountBalanceRequest( 25 | request_id=message_obj.get('RequestID'), 26 | trade_account=message_obj.get('TradeAccount') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return AccountBalanceRequest.from_message_short(message_obj) 33 | else: 34 | return AccountBalanceRequest.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "AccountBalanceRequest" 39 | -------------------------------------------------------------------------------- /dtc/message_types/account_balance_update.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AccountBalanceUpdate(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | cash_balance=None, 10 | balance_available_for_new_positions=None, 11 | account_currency=None, 12 | trade_account=None, 13 | securities_value=None, 14 | margin_requirement=None, 15 | total_number_messages=None, 16 | message_number=None, 17 | no_account_balances=None, 18 | unsolicited=None, 19 | open_positions_profit_loss=None, 20 | daily_profit_loss=None, 21 | info_text=None, 22 | transaction_identifier=None): 23 | self.Type = MessageTypes.ACCOUNT_BALANCE_UPDATE 24 | self.RequestID = request_id 25 | self.CashBalance = cash_balance 26 | self.BalanceAvailableForNewPositions = balance_available_for_new_positions 27 | self.AccountCurrency = account_currency 28 | self.TradeAccount = trade_account 29 | self.SecuritiesValue = securities_value 30 | self.MarginRequirement = margin_requirement 31 | self.TotalNumberMessages = total_number_messages 32 | self.MessageNumber = message_number 33 | self.NoAccountBalances = no_account_balances 34 | self.Unsolicited = unsolicited 35 | self.OpenPositionsProfitLoss = open_positions_profit_loss 36 | self.DailyProfitLoss = daily_profit_loss 37 | self.InfoText = info_text 38 | self.TransactionIdentifier = transaction_identifier 39 | 40 | @staticmethod 41 | def from_message_short(message_obj): 42 | packet = message_obj.get('F') 43 | return AccountBalanceUpdate( 44 | request_id=packet[0], 45 | cash_balance=packet[1], 46 | balance_available_for_new_positions=packet[2], 47 | account_currency=packet[3], 48 | trade_account=packet[4], 49 | securities_value=packet[5], 50 | margin_requirement=packet[6], 51 | total_number_messages=packet[7], 52 | message_number=packet[8], 53 | no_account_balances=packet[9], 54 | unsolicited=packet[10], 55 | open_positions_profit_loss=packet[11], 56 | daily_profit_loss=packet[12], 57 | info_text=packet[13], 58 | transaction_identifier=packet[14] 59 | ) 60 | 61 | @staticmethod 62 | def from_message_long(message_obj): 63 | return AccountBalanceUpdate( 64 | request_id=message_obj.get('RequestID'), 65 | cash_balance=message_obj.get('CashBalance'), 66 | balance_available_for_new_positions=message_obj.get('BalanceAvailableForNewPositions'), 67 | account_currency=message_obj.get('AccountCurrency'), 68 | trade_account=message_obj.get('TradeAccount'), 69 | securities_value=message_obj.get('SecuritiesValue'), 70 | margin_requirement=message_obj.get('MarginRequirement'), 71 | total_number_messages=message_obj.get('TotalNumberMessages'), 72 | message_number=message_obj.get('MessageNumber'), 73 | no_account_balances=message_obj.get('NoAccountBalances'), 74 | unsolicited=message_obj.get('Unsolicited'), 75 | open_positions_profit_loss=message_obj.get('OpenPositionsProfitLoss'), 76 | daily_profit_loss=message_obj.get('DailyProfitLoss'), 77 | info_text=message_obj.get('InfoText'), 78 | transaction_identifier=message_obj.get('TransactionIdentifier') 79 | ) 80 | 81 | @staticmethod 82 | def from_message(message_obj): 83 | if 'F' in message_obj: 84 | return AccountBalanceUpdate.from_message_short(message_obj) 85 | else: 86 | return AccountBalanceUpdate.from_message_long(message_obj) 87 | 88 | @staticmethod 89 | def get_message_type_name(): 90 | return "AccountBalanceUpdate" 91 | -------------------------------------------------------------------------------- /dtc/message_types/alert_message.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class AlertMessage(BaseMessageType): 7 | def __init__(self, 8 | message_text=None, 9 | trade_account=None): 10 | self.Type = MessageTypes.ALERT_MESSAGE 11 | self.MessageText = message_text 12 | self.TradeAccount = trade_account 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return AlertMessage( 18 | message_text=packet[0], 19 | trade_account=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return AlertMessage( 25 | message_text=message_obj.get('MessageText'), 26 | trade_account=message_obj.get('TradeAccount') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return AlertMessage.from_message_short(message_obj) 33 | else: 34 | return AlertMessage.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "AlertMessage" 39 | -------------------------------------------------------------------------------- /dtc/message_types/cancel_order.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class CancelOrder(BaseMessageType): 7 | def __init__(self, 8 | server_order_id=None, 9 | client_order_id=None): 10 | self.Type = MessageTypes.CANCEL_ORDER 11 | self.ServerOrderID = server_order_id 12 | self.ClientOrderID = client_order_id 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return CancelOrder( 18 | server_order_id=packet[0], 19 | client_order_id=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return CancelOrder( 25 | server_order_id=message_obj.get('ServerOrderID'), 26 | client_order_id=message_obj.get('ClientOrderID') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return CancelOrder.from_message_short(message_obj) 33 | else: 34 | return CancelOrder.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "CancelOrder" 39 | -------------------------------------------------------------------------------- /dtc/message_types/cancel_replace_order.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class CancelReplaceOrder(BaseMessageType): 7 | def __init__(self, 8 | server_order_id=None, 9 | client_order_id=None, 10 | price1=None, 11 | price2=None, 12 | quantity=None, 13 | price1_is_set=None, 14 | price2_is_set=None, 15 | unused=None, 16 | time_in_force=None, 17 | good_till_date_time=None, 18 | update_price1_offset_to_parent=None): 19 | self.Type = MessageTypes.CANCEL_REPLACE_ORDER 20 | self.ServerOrderID = server_order_id 21 | self.ClientOrderID = client_order_id 22 | self.Price1 = price1 23 | self.Price2 = price2 24 | self.Quantity = quantity 25 | self.Price1IsSet = price1_is_set 26 | self.Price2IsSet = price2_is_set 27 | self.Unused = unused 28 | self.TimeInForce = time_in_force 29 | self.GoodTillDateTime = good_till_date_time 30 | self.UpdatePrice1OffsetToParent = update_price1_offset_to_parent 31 | 32 | @staticmethod 33 | def from_message_short(message_obj): 34 | packet = message_obj.get('F') 35 | return CancelReplaceOrder( 36 | server_order_id=packet[0], 37 | client_order_id=packet[1], 38 | price1=packet[2], 39 | price2=packet[3], 40 | quantity=packet[4], 41 | price1_is_set=packet[5], 42 | price2_is_set=packet[6], 43 | unused=packet[7], 44 | time_in_force=packet[8], 45 | good_till_date_time=packet[9], 46 | update_price1_offset_to_parent=packet[10] 47 | ) 48 | 49 | @staticmethod 50 | def from_message_long(message_obj): 51 | return CancelReplaceOrder( 52 | server_order_id=message_obj.get('ServerOrderID'), 53 | client_order_id=message_obj.get('ClientOrderID'), 54 | price1=message_obj.get('Price1'), 55 | price2=message_obj.get('Price2'), 56 | quantity=message_obj.get('Quantity'), 57 | price1_is_set=message_obj.get('Price1IsSet'), 58 | price2_is_set=message_obj.get('Price2IsSet'), 59 | unused=message_obj.get('Unused'), 60 | time_in_force=message_obj.get('TimeInForce'), 61 | good_till_date_time=message_obj.get('GoodTillDateTime'), 62 | update_price1_offset_to_parent=message_obj.get('UpdatePrice1OffsetToParent') 63 | ) 64 | 65 | @staticmethod 66 | def from_message(message_obj): 67 | if 'F' in message_obj: 68 | return CancelReplaceOrder.from_message_short(message_obj) 69 | else: 70 | return CancelReplaceOrder.from_message_long(message_obj) 71 | 72 | @staticmethod 73 | def get_message_type_name(): 74 | return "CancelReplaceOrder" 75 | -------------------------------------------------------------------------------- /dtc/message_types/cancel_replace_order_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class CancelReplaceOrderInt(BaseMessageType): 7 | def __init__(self, 8 | server_order_id=None, 9 | client_order_id=None, 10 | price1=None, 11 | price2=None, 12 | divisor=None, 13 | quantity=None, 14 | price1_is_set=None, 15 | price2_is_set=None, 16 | unused=None, 17 | time_in_force=None, 18 | good_till_date_time=None, 19 | update_price1_offset_to_parent=None): 20 | self.Type = MessageTypes.CANCEL_REPLACE_ORDER_INT 21 | self.ServerOrderID = server_order_id 22 | self.ClientOrderID = client_order_id 23 | self.Price1 = price1 24 | self.Price2 = price2 25 | self.Divisor = divisor 26 | self.Quantity = quantity 27 | self.Price1IsSet = price1_is_set 28 | self.Price2IsSet = price2_is_set 29 | self.Unused = unused 30 | self.TimeInForce = time_in_force 31 | self.GoodTillDateTime = good_till_date_time 32 | self.UpdatePrice1OffsetToParent = update_price1_offset_to_parent 33 | 34 | @staticmethod 35 | def from_message_short(message_obj): 36 | packet = message_obj.get('F') 37 | return CancelReplaceOrderInt( 38 | server_order_id=packet[0], 39 | client_order_id=packet[1], 40 | price1=packet[2], 41 | price2=packet[3], 42 | divisor=packet[4], 43 | quantity=packet[5], 44 | price1_is_set=packet[6], 45 | price2_is_set=packet[7], 46 | unused=packet[8], 47 | time_in_force=packet[9], 48 | good_till_date_time=packet[10], 49 | update_price1_offset_to_parent=packet[11] 50 | ) 51 | 52 | @staticmethod 53 | def from_message_long(message_obj): 54 | return CancelReplaceOrderInt( 55 | server_order_id=message_obj.get('ServerOrderID'), 56 | client_order_id=message_obj.get('ClientOrderID'), 57 | price1=message_obj.get('Price1'), 58 | price2=message_obj.get('Price2'), 59 | divisor=message_obj.get('Divisor'), 60 | quantity=message_obj.get('Quantity'), 61 | price1_is_set=message_obj.get('Price1IsSet'), 62 | price2_is_set=message_obj.get('Price2IsSet'), 63 | unused=message_obj.get('Unused'), 64 | time_in_force=message_obj.get('TimeInForce'), 65 | good_till_date_time=message_obj.get('GoodTillDateTime'), 66 | update_price1_offset_to_parent=message_obj.get('UpdatePrice1OffsetToParent') 67 | ) 68 | 69 | @staticmethod 70 | def from_message(message_obj): 71 | if 'F' in message_obj: 72 | return CancelReplaceOrderInt.from_message_short(message_obj) 73 | else: 74 | return CancelReplaceOrderInt.from_message_long(message_obj) 75 | 76 | @staticmethod 77 | def get_message_type_name(): 78 | return "CancelReplaceOrderInt" 79 | -------------------------------------------------------------------------------- /dtc/message_types/current_positions_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class CurrentPositionsReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.CURRENT_POSITIONS_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return CurrentPositionsReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return CurrentPositionsReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return CurrentPositionsReject.from_message_short(message_obj) 33 | else: 34 | return CurrentPositionsReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "CurrentPositionsReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/current_positions_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class CurrentPositionsRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | trade_account=None): 10 | self.Type = MessageTypes.CURRENT_POSITIONS_REQUEST 11 | self.RequestID = request_id 12 | self.TradeAccount = trade_account 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return CurrentPositionsRequest( 18 | request_id=packet[0], 19 | trade_account=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return CurrentPositionsRequest( 25 | request_id=message_obj.get('RequestID'), 26 | trade_account=message_obj.get('TradeAccount') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return CurrentPositionsRequest.from_message_short(message_obj) 33 | else: 34 | return CurrentPositionsRequest.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "CurrentPositionsRequest" 39 | -------------------------------------------------------------------------------- /dtc/message_types/encoding_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class EncodingRequest(BaseMessageType): 7 | def __init__(self, 8 | protocol_version=None, 9 | encoding=None, 10 | protocol_type=None): 11 | self.Type = MessageTypes.ENCODING_REQUEST 12 | self.ProtocolVersion = protocol_version 13 | self.Encoding = encoding 14 | self.ProtocolType = protocol_type 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return EncodingRequest( 20 | protocol_version=packet[0], 21 | encoding=packet[1], 22 | protocol_type=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return EncodingRequest( 28 | protocol_version=message_obj.get('ProtocolVersion'), 29 | encoding=message_obj.get('Encoding'), 30 | protocol_type=message_obj.get('ProtocolType') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return EncodingRequest.from_message_short(message_obj) 37 | else: 38 | return EncodingRequest.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "EncodingRequest" 43 | -------------------------------------------------------------------------------- /dtc/message_types/encoding_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class EncodingResponse(BaseMessageType): 7 | def __init__(self, 8 | protocol_version=None, 9 | encoding=None, 10 | protocol_type=None): 11 | self.Type = MessageTypes.ENCODING_RESPONSE 12 | self.ProtocolVersion = protocol_version 13 | self.Encoding = encoding 14 | self.ProtocolType = protocol_type 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return EncodingResponse( 20 | protocol_version=packet[0], 21 | encoding=packet[1], 22 | protocol_type=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return EncodingResponse( 28 | protocol_version=message_obj.get('ProtocolVersion'), 29 | encoding=message_obj.get('Encoding'), 30 | protocol_type=message_obj.get('ProtocolType') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return EncodingResponse.from_message_short(message_obj) 37 | else: 38 | return EncodingResponse.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "EncodingResponse" 43 | -------------------------------------------------------------------------------- /dtc/message_types/exchange_list_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class ExchangeListRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None): 9 | self.Type = MessageTypes.EXCHANGE_LIST_REQUEST 10 | self.RequestID = request_id 11 | 12 | @staticmethod 13 | def from_message_short(message_obj): 14 | packet = message_obj.get('F') 15 | return ExchangeListRequest( 16 | request_id=packet[0] 17 | ) 18 | 19 | @staticmethod 20 | def from_message_long(message_obj): 21 | return ExchangeListRequest( 22 | request_id=message_obj.get('RequestID') 23 | ) 24 | 25 | @staticmethod 26 | def from_message(message_obj): 27 | if 'F' in message_obj: 28 | return ExchangeListRequest.from_message_short(message_obj) 29 | else: 30 | return ExchangeListRequest.from_message_long(message_obj) 31 | 32 | @staticmethod 33 | def get_message_type_name(): 34 | return "ExchangeListRequest" 35 | -------------------------------------------------------------------------------- /dtc/message_types/exchange_list_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class ExchangeListResponse(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | exchange=None, 10 | is_final_message=None, 11 | description=None): 12 | self.Type = MessageTypes.EXCHANGE_LIST_RESPONSE 13 | self.RequestID = request_id 14 | self.Exchange = exchange 15 | self.IsFinalMessage = is_final_message 16 | self.Description = description 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return ExchangeListResponse( 22 | request_id=packet[0], 23 | exchange=packet[1], 24 | is_final_message=packet[2], 25 | description=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return ExchangeListResponse( 31 | request_id=message_obj.get('RequestID'), 32 | exchange=message_obj.get('Exchange'), 33 | is_final_message=message_obj.get('IsFinalMessage'), 34 | description=message_obj.get('Description') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return ExchangeListResponse.from_message_short(message_obj) 41 | else: 42 | return ExchangeListResponse.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "ExchangeListResponse" 47 | -------------------------------------------------------------------------------- /dtc/message_types/general_log_message.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class GeneralLogMessage(BaseMessageType): 7 | def __init__(self, 8 | message_text=None): 9 | self.Type = MessageTypes.GENERAL_LOG_MESSAGE 10 | self.MessageText = message_text 11 | 12 | @staticmethod 13 | def from_message_short(message_obj): 14 | packet = message_obj.get('F') 15 | return GeneralLogMessage( 16 | message_text=packet[0] 17 | ) 18 | 19 | @staticmethod 20 | def from_message_long(message_obj): 21 | return GeneralLogMessage( 22 | message_text=message_obj.get('MessageText') 23 | ) 24 | 25 | @staticmethod 26 | def from_message(message_obj): 27 | if 'F' in message_obj: 28 | return GeneralLogMessage.from_message_short(message_obj) 29 | else: 30 | return GeneralLogMessage.from_message_long(message_obj) 31 | 32 | @staticmethod 33 | def get_message_type_name(): 34 | return "GeneralLogMessage" 35 | -------------------------------------------------------------------------------- /dtc/message_types/heartbeat.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class Heartbeat(BaseMessageType): 7 | def __init__(self, 8 | num_dropped_messages=None, 9 | current_date_time=None): 10 | self.Type = MessageTypes.HEARTBEAT 11 | self.NumDroppedMessages = num_dropped_messages 12 | self.CurrentDateTime = current_date_time 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return Heartbeat( 18 | num_dropped_messages=packet[0], 19 | current_date_time=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return Heartbeat( 25 | num_dropped_messages=message_obj.get('NumDroppedMessages'), 26 | current_date_time=message_obj.get('CurrentDateTime') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return Heartbeat.from_message_short(message_obj) 33 | else: 34 | return Heartbeat.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "Heartbeat" 39 | -------------------------------------------------------------------------------- /dtc/message_types/historical_account_balance_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalAccountBalanceResponse(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | date_time=None, 10 | cash_balance=None, 11 | account_currency=None, 12 | trade_account=None, 13 | is_final_response=None, 14 | no_account_balances=None, 15 | info_text=None, 16 | transaction_id=None): 17 | self.Type = MessageTypes.HISTORICAL_ACCOUNT_BALANCE_RESPONSE 18 | self.RequestID = request_id 19 | self.DateTime = date_time 20 | self.CashBalance = cash_balance 21 | self.AccountCurrency = account_currency 22 | self.TradeAccount = trade_account 23 | self.IsFinalResponse = is_final_response 24 | self.NoAccountBalances = no_account_balances 25 | self.InfoText = info_text 26 | self.TransactionId = transaction_id 27 | 28 | @staticmethod 29 | def from_message_short(message_obj): 30 | packet = message_obj.get('F') 31 | return HistoricalAccountBalanceResponse( 32 | request_id=packet[0], 33 | date_time=packet[1], 34 | cash_balance=packet[2], 35 | account_currency=packet[3], 36 | trade_account=packet[4], 37 | is_final_response=packet[5], 38 | no_account_balances=packet[6], 39 | info_text=packet[7], 40 | transaction_id=packet[8] 41 | ) 42 | 43 | @staticmethod 44 | def from_message_long(message_obj): 45 | return HistoricalAccountBalanceResponse( 46 | request_id=message_obj.get('RequestID'), 47 | date_time=message_obj.get('DateTime'), 48 | cash_balance=message_obj.get('CashBalance'), 49 | account_currency=message_obj.get('AccountCurrency'), 50 | trade_account=message_obj.get('TradeAccount'), 51 | is_final_response=message_obj.get('IsFinalResponse'), 52 | no_account_balances=message_obj.get('NoAccountBalances'), 53 | info_text=message_obj.get('InfoText'), 54 | transaction_id=message_obj.get('TransactionId') 55 | ) 56 | 57 | @staticmethod 58 | def from_message(message_obj): 59 | if 'F' in message_obj: 60 | return HistoricalAccountBalanceResponse.from_message_short(message_obj) 61 | else: 62 | return HistoricalAccountBalanceResponse.from_message_long(message_obj) 63 | 64 | @staticmethod 65 | def get_message_type_name(): 66 | return "HistoricalAccountBalanceResponse" 67 | -------------------------------------------------------------------------------- /dtc/message_types/historical_account_balances_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalAccountBalancesReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.HISTORICAL_ACCOUNT_BALANCES_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return HistoricalAccountBalancesReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return HistoricalAccountBalancesReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return HistoricalAccountBalancesReject.from_message_short(message_obj) 33 | else: 34 | return HistoricalAccountBalancesReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "HistoricalAccountBalancesReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/historical_account_balances_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalAccountBalancesRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | trade_account=None, 10 | start_date_time=None): 11 | self.Type = MessageTypes.HISTORICAL_ACCOUNT_BALANCES_REQUEST 12 | self.RequestID = request_id 13 | self.TradeAccount = trade_account 14 | self.StartDateTime = start_date_time 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return HistoricalAccountBalancesRequest( 20 | request_id=packet[0], 21 | trade_account=packet[1], 22 | start_date_time=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return HistoricalAccountBalancesRequest( 28 | request_id=message_obj.get('RequestID'), 29 | trade_account=message_obj.get('TradeAccount'), 30 | start_date_time=message_obj.get('StartDateTime') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return HistoricalAccountBalancesRequest.from_message_short(message_obj) 37 | else: 38 | return HistoricalAccountBalancesRequest.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "HistoricalAccountBalancesRequest" 43 | -------------------------------------------------------------------------------- /dtc/message_types/historical_order_fill_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalOrderFillResponse(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | total_number_messages=None, 10 | message_number=None, 11 | symbol=None, 12 | exchange=None, 13 | server_order_id=None, 14 | buy_sell=None, 15 | price=None, 16 | date_time=None, 17 | quantity=None, 18 | unique_execution_id=None, 19 | trade_account=None, 20 | open_close=None, 21 | no_order_fills=None, 22 | info_text=None, 23 | high_price_during_position=None, 24 | low_price_during_position=None, 25 | position_quantity=None): 26 | self.Type = MessageTypes.HISTORICAL_ORDER_FILL_RESPONSE 27 | self.RequestID = request_id 28 | self.TotalNumberMessages = total_number_messages 29 | self.MessageNumber = message_number 30 | self.Symbol = symbol 31 | self.Exchange = exchange 32 | self.ServerOrderID = server_order_id 33 | self.BuySell = buy_sell 34 | self.Price = price 35 | self.DateTime = date_time 36 | self.Quantity = quantity 37 | self.UniqueExecutionID = unique_execution_id 38 | self.TradeAccount = trade_account 39 | self.OpenClose = open_close 40 | self.NoOrderFills = no_order_fills 41 | self.InfoText = info_text 42 | self.HighPriceDuringPosition = high_price_during_position 43 | self.LowPriceDuringPosition = low_price_during_position 44 | self.PositionQuantity = position_quantity 45 | 46 | @staticmethod 47 | def from_message_short(message_obj): 48 | packet = message_obj.get('F') 49 | return HistoricalOrderFillResponse( 50 | request_id=packet[0], 51 | total_number_messages=packet[1], 52 | message_number=packet[2], 53 | symbol=packet[3], 54 | exchange=packet[4], 55 | server_order_id=packet[5], 56 | buy_sell=packet[6], 57 | price=packet[7], 58 | date_time=packet[8], 59 | quantity=packet[9], 60 | unique_execution_id=packet[10], 61 | trade_account=packet[11], 62 | open_close=packet[12], 63 | no_order_fills=packet[13], 64 | info_text=packet[14], 65 | high_price_during_position=packet[15], 66 | low_price_during_position=packet[16], 67 | position_quantity=packet[17] 68 | ) 69 | 70 | @staticmethod 71 | def from_message_long(message_obj): 72 | return HistoricalOrderFillResponse( 73 | request_id=message_obj.get('RequestID'), 74 | total_number_messages=message_obj.get('TotalNumberMessages'), 75 | message_number=message_obj.get('MessageNumber'), 76 | symbol=message_obj.get('Symbol'), 77 | exchange=message_obj.get('Exchange'), 78 | server_order_id=message_obj.get('ServerOrderID'), 79 | buy_sell=message_obj.get('BuySell'), 80 | price=message_obj.get('Price'), 81 | date_time=message_obj.get('DateTime'), 82 | quantity=message_obj.get('Quantity'), 83 | unique_execution_id=message_obj.get('UniqueExecutionID'), 84 | trade_account=message_obj.get('TradeAccount'), 85 | open_close=message_obj.get('OpenClose'), 86 | no_order_fills=message_obj.get('NoOrderFills'), 87 | info_text=message_obj.get('InfoText'), 88 | high_price_during_position=message_obj.get('HighPriceDuringPosition'), 89 | low_price_during_position=message_obj.get('LowPriceDuringPosition'), 90 | position_quantity=message_obj.get('PositionQuantity') 91 | ) 92 | 93 | @staticmethod 94 | def from_message(message_obj): 95 | if 'F' in message_obj: 96 | return HistoricalOrderFillResponse.from_message_short(message_obj) 97 | else: 98 | return HistoricalOrderFillResponse.from_message_long(message_obj) 99 | 100 | @staticmethod 101 | def get_message_type_name(): 102 | return "HistoricalOrderFillResponse" 103 | -------------------------------------------------------------------------------- /dtc/message_types/historical_order_fills_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalOrderFillsReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.HISTORICAL_ORDER_FILLS_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return HistoricalOrderFillsReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return HistoricalOrderFillsReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return HistoricalOrderFillsReject.from_message_short(message_obj) 33 | else: 34 | return HistoricalOrderFillsReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "HistoricalOrderFillsReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/historical_order_fills_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalOrderFillsRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | server_order_id=None, 10 | number_of_days=None, 11 | trade_account=None, 12 | start_date_time=None): 13 | self.Type = MessageTypes.HISTORICAL_ORDER_FILLS_REQUEST 14 | self.RequestID = request_id 15 | self.ServerOrderID = server_order_id 16 | self.NumberOfDays = number_of_days 17 | self.TradeAccount = trade_account 18 | self.StartDateTime = start_date_time 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return HistoricalOrderFillsRequest( 24 | request_id=packet[0], 25 | server_order_id=packet[1], 26 | number_of_days=packet[2], 27 | trade_account=packet[3], 28 | start_date_time=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return HistoricalOrderFillsRequest( 34 | request_id=message_obj.get('RequestID'), 35 | server_order_id=message_obj.get('ServerOrderID'), 36 | number_of_days=message_obj.get('NumberOfDays'), 37 | trade_account=message_obj.get('TradeAccount'), 38 | start_date_time=message_obj.get('StartDateTime') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return HistoricalOrderFillsRequest.from_message_short(message_obj) 45 | else: 46 | return HistoricalOrderFillsRequest.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "HistoricalOrderFillsRequest" 51 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_record_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataRecordResponse(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | start_date_time=None, 10 | open_price=None, 11 | high_price=None, 12 | low_price=None, 13 | last_price=None, 14 | volume=None, 15 | bid_volume=None, 16 | ask_volume=None, 17 | is_final_record=None): 18 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_RECORD_RESPONSE 19 | self.RequestID = request_id 20 | self.StartDateTime = start_date_time 21 | self.OpenPrice = open_price 22 | self.HighPrice = high_price 23 | self.LowPrice = low_price 24 | self.LastPrice = last_price 25 | self.Volume = volume 26 | self.BidVolume = bid_volume 27 | self.AskVolume = ask_volume 28 | self.IsFinalRecord = is_final_record 29 | 30 | @staticmethod 31 | def from_message_short(message_obj): 32 | packet = message_obj.get('F') 33 | return HistoricalPriceDataRecordResponse( 34 | request_id=packet[0], 35 | start_date_time=packet[1], 36 | open_price=packet[2], 37 | high_price=packet[3], 38 | low_price=packet[4], 39 | last_price=packet[5], 40 | volume=packet[6], 41 | bid_volume=packet[7], 42 | ask_volume=packet[8], 43 | is_final_record=packet[9] 44 | ) 45 | 46 | @staticmethod 47 | def from_message_long(message_obj): 48 | return HistoricalPriceDataRecordResponse( 49 | request_id=message_obj.get('RequestID'), 50 | start_date_time=message_obj.get('StartDateTime'), 51 | open_price=message_obj.get('OpenPrice'), 52 | high_price=message_obj.get('HighPrice'), 53 | low_price=message_obj.get('LowPrice'), 54 | last_price=message_obj.get('LastPrice'), 55 | volume=message_obj.get('Volume'), 56 | bid_volume=message_obj.get('BidVolume'), 57 | ask_volume=message_obj.get('AskVolume'), 58 | is_final_record=message_obj.get('IsFinalRecord') 59 | ) 60 | 61 | @staticmethod 62 | def from_message(message_obj): 63 | if 'F' in message_obj: 64 | return HistoricalPriceDataRecordResponse.from_message_short(message_obj) 65 | else: 66 | return HistoricalPriceDataRecordResponse.from_message_long(message_obj) 67 | 68 | @staticmethod 69 | def get_message_type_name(): 70 | return "HistoricalPriceDataRecordResponse" 71 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_record_response_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataRecordResponseInt(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | start_date_time=None, 10 | open_price=None, 11 | high_price=None, 12 | low_price=None, 13 | last_price=None, 14 | volume=None, 15 | bid_volume=None, 16 | ask_volume=None, 17 | is_final_record=None): 18 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_RECORD_RESPONSE_INT 19 | self.RequestID = request_id 20 | self.StartDateTime = start_date_time 21 | self.OpenPrice = open_price 22 | self.HighPrice = high_price 23 | self.LowPrice = low_price 24 | self.LastPrice = last_price 25 | self.Volume = volume 26 | self.BidVolume = bid_volume 27 | self.AskVolume = ask_volume 28 | self.IsFinalRecord = is_final_record 29 | 30 | @staticmethod 31 | def from_message_short(message_obj): 32 | packet = message_obj.get('F') 33 | return HistoricalPriceDataRecordResponseInt( 34 | request_id=packet[0], 35 | start_date_time=packet[1], 36 | open_price=packet[2], 37 | high_price=packet[3], 38 | low_price=packet[4], 39 | last_price=packet[5], 40 | volume=packet[6], 41 | bid_volume=packet[7], 42 | ask_volume=packet[8], 43 | is_final_record=packet[9] 44 | ) 45 | 46 | @staticmethod 47 | def from_message_long(message_obj): 48 | return HistoricalPriceDataRecordResponseInt( 49 | request_id=message_obj.get('RequestID'), 50 | start_date_time=message_obj.get('StartDateTime'), 51 | open_price=message_obj.get('OpenPrice'), 52 | high_price=message_obj.get('HighPrice'), 53 | low_price=message_obj.get('LowPrice'), 54 | last_price=message_obj.get('LastPrice'), 55 | volume=message_obj.get('Volume'), 56 | bid_volume=message_obj.get('BidVolume'), 57 | ask_volume=message_obj.get('AskVolume'), 58 | is_final_record=message_obj.get('IsFinalRecord') 59 | ) 60 | 61 | @staticmethod 62 | def from_message(message_obj): 63 | if 'F' in message_obj: 64 | return HistoricalPriceDataRecordResponseInt.from_message_short(message_obj) 65 | else: 66 | return HistoricalPriceDataRecordResponseInt.from_message_long(message_obj) 67 | 68 | @staticmethod 69 | def get_message_type_name(): 70 | return "HistoricalPriceDataRecordResponseInt" 71 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None, 10 | reject_reason_code=None, 11 | retry_time_in_seconds=None): 12 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_REJECT 13 | self.RequestID = request_id 14 | self.RejectText = reject_text 15 | self.RejectReasonCode = reject_reason_code 16 | self.RetryTimeInSeconds = retry_time_in_seconds 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return HistoricalPriceDataReject( 22 | request_id=packet[0], 23 | reject_text=packet[1], 24 | reject_reason_code=packet[2], 25 | retry_time_in_seconds=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return HistoricalPriceDataReject( 31 | request_id=message_obj.get('RequestID'), 32 | reject_text=message_obj.get('RejectText'), 33 | reject_reason_code=message_obj.get('RejectReasonCode'), 34 | retry_time_in_seconds=message_obj.get('RetryTimeInSeconds') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return HistoricalPriceDataReject.from_message_short(message_obj) 41 | else: 42 | return HistoricalPriceDataReject.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "HistoricalPriceDataReject" 47 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | symbol=None, 10 | exchange=None, 11 | record_interval=None, 12 | start_date_time=None, 13 | end_date_time=None, 14 | max_days_to_return=None, 15 | use_z_lib_compression=None, 16 | request_dividend_adjusted_stock_data=None, 17 | flag_1=None): 18 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_REQUEST 19 | self.RequestID = request_id 20 | self.Symbol = symbol 21 | self.Exchange = exchange 22 | self.RecordInterval = record_interval 23 | self.StartDateTime = start_date_time 24 | self.EndDateTime = end_date_time 25 | self.MaxDaysToReturn = max_days_to_return 26 | self.UseZLibCompression = use_z_lib_compression 27 | self.RequestDividendAdjustedStockData = request_dividend_adjusted_stock_data 28 | self.Flag_1 = flag_1 29 | 30 | @staticmethod 31 | def from_message_short(message_obj): 32 | packet = message_obj.get('F') 33 | return HistoricalPriceDataRequest( 34 | request_id=packet[0], 35 | symbol=packet[1], 36 | exchange=packet[2], 37 | record_interval=packet[3], 38 | start_date_time=packet[4], 39 | end_date_time=packet[5], 40 | max_days_to_return=packet[6], 41 | use_z_lib_compression=packet[7], 42 | request_dividend_adjusted_stock_data=packet[8], 43 | flag_1=packet[9] 44 | ) 45 | 46 | @staticmethod 47 | def from_message_long(message_obj): 48 | return HistoricalPriceDataRequest( 49 | request_id=message_obj.get('RequestID'), 50 | symbol=message_obj.get('Symbol'), 51 | exchange=message_obj.get('Exchange'), 52 | record_interval=message_obj.get('RecordInterval'), 53 | start_date_time=message_obj.get('StartDateTime'), 54 | end_date_time=message_obj.get('EndDateTime'), 55 | max_days_to_return=message_obj.get('MaxDaysToReturn'), 56 | use_z_lib_compression=message_obj.get('UseZLibCompression'), 57 | request_dividend_adjusted_stock_data=message_obj.get('RequestDividendAdjustedStockData'), 58 | flag_1=message_obj.get('Flag_1') 59 | ) 60 | 61 | @staticmethod 62 | def from_message(message_obj): 63 | if 'F' in message_obj: 64 | return HistoricalPriceDataRequest.from_message_short(message_obj) 65 | else: 66 | return HistoricalPriceDataRequest.from_message_long(message_obj) 67 | 68 | @staticmethod 69 | def get_message_type_name(): 70 | return "HistoricalPriceDataRequest" 71 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_response_header.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataResponseHeader(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | record_interval=None, 10 | use_z_lib_compression=None, 11 | no_records_to_return=None, 12 | int_to_float_price_divisor=None): 13 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_RESPONSE_HEADER 14 | self.RequestID = request_id 15 | self.RecordInterval = record_interval 16 | self.UseZLibCompression = use_z_lib_compression 17 | self.NoRecordsToReturn = no_records_to_return 18 | self.IntToFloatPriceDivisor = int_to_float_price_divisor 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return HistoricalPriceDataResponseHeader( 24 | request_id=packet[0], 25 | record_interval=packet[1], 26 | use_z_lib_compression=packet[2], 27 | no_records_to_return=packet[3], 28 | int_to_float_price_divisor=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return HistoricalPriceDataResponseHeader( 34 | request_id=message_obj.get('RequestID'), 35 | record_interval=message_obj.get('RecordInterval'), 36 | use_z_lib_compression=message_obj.get('UseZLibCompression'), 37 | no_records_to_return=message_obj.get('NoRecordsToReturn'), 38 | int_to_float_price_divisor=message_obj.get('IntToFloatPriceDivisor') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return HistoricalPriceDataResponseHeader.from_message_short(message_obj) 45 | else: 46 | return HistoricalPriceDataResponseHeader.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "HistoricalPriceDataResponseHeader" 51 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_response_trailer.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataResponseTrailer(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | final_record_last_date_time=None): 10 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_RESPONSE_TRAILER 11 | self.RequestID = request_id 12 | self.FinalRecordLastDateTime = final_record_last_date_time 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return HistoricalPriceDataResponseTrailer( 18 | request_id=packet[0], 19 | final_record_last_date_time=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return HistoricalPriceDataResponseTrailer( 25 | request_id=message_obj.get('RequestID'), 26 | final_record_last_date_time=message_obj.get('FinalRecordLastDateTime') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return HistoricalPriceDataResponseTrailer.from_message_short(message_obj) 33 | else: 34 | return HistoricalPriceDataResponseTrailer.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "HistoricalPriceDataResponseTrailer" 39 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_tick_record_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataTickRecordResponse(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | date_time=None, 10 | at_bid_or_ask=None, 11 | price=None, 12 | volume=None, 13 | is_final_record=None): 14 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_TICK_RECORD_RESPONSE 15 | self.RequestID = request_id 16 | self.DateTime = date_time 17 | self.AtBidOrAsk = at_bid_or_ask 18 | self.Price = price 19 | self.Volume = volume 20 | self.IsFinalRecord = is_final_record 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return HistoricalPriceDataTickRecordResponse( 26 | request_id=packet[0], 27 | date_time=packet[1], 28 | at_bid_or_ask=packet[2], 29 | price=packet[3], 30 | volume=packet[4], 31 | is_final_record=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return HistoricalPriceDataTickRecordResponse( 37 | request_id=message_obj.get('RequestID'), 38 | date_time=message_obj.get('DateTime'), 39 | at_bid_or_ask=message_obj.get('AtBidOrAsk'), 40 | price=message_obj.get('Price'), 41 | volume=message_obj.get('Volume'), 42 | is_final_record=message_obj.get('IsFinalRecord') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return HistoricalPriceDataTickRecordResponse.from_message_short(message_obj) 49 | else: 50 | return HistoricalPriceDataTickRecordResponse.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "HistoricalPriceDataTickRecordResponse" 55 | -------------------------------------------------------------------------------- /dtc/message_types/historical_price_data_tick_record_response_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class HistoricalPriceDataTickRecordResponseInt(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | date_time=None, 10 | price=None, 11 | volume=None, 12 | at_bid_or_ask=None, 13 | is_final_record=None): 14 | self.Type = MessageTypes.HISTORICAL_PRICE_DATA_TICK_RECORD_RESPONSE_INT 15 | self.RequestID = request_id 16 | self.DateTime = date_time 17 | self.Price = price 18 | self.Volume = volume 19 | self.AtBidOrAsk = at_bid_or_ask 20 | self.IsFinalRecord = is_final_record 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return HistoricalPriceDataTickRecordResponseInt( 26 | request_id=packet[0], 27 | date_time=packet[1], 28 | price=packet[2], 29 | volume=packet[3], 30 | at_bid_or_ask=packet[4], 31 | is_final_record=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return HistoricalPriceDataTickRecordResponseInt( 37 | request_id=message_obj.get('RequestID'), 38 | date_time=message_obj.get('DateTime'), 39 | price=message_obj.get('Price'), 40 | volume=message_obj.get('Volume'), 41 | at_bid_or_ask=message_obj.get('AtBidOrAsk'), 42 | is_final_record=message_obj.get('IsFinalRecord') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return HistoricalPriceDataTickRecordResponseInt.from_message_short(message_obj) 49 | else: 50 | return HistoricalPriceDataTickRecordResponseInt.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "HistoricalPriceDataTickRecordResponseInt" 55 | -------------------------------------------------------------------------------- /dtc/message_types/journal_entries_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class JournalEntriesReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.JOURNAL_ENTRIES_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return JournalEntriesReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return JournalEntriesReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return JournalEntriesReject.from_message_short(message_obj) 33 | else: 34 | return JournalEntriesReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "JournalEntriesReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/journal_entries_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class JournalEntriesRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | start_date_time=None): 10 | self.Type = MessageTypes.JOURNAL_ENTRIES_REQUEST 11 | self.RequestID = request_id 12 | self.StartDateTime = start_date_time 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return JournalEntriesRequest( 18 | request_id=packet[0], 19 | start_date_time=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return JournalEntriesRequest( 25 | request_id=message_obj.get('RequestID'), 26 | start_date_time=message_obj.get('StartDateTime') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return JournalEntriesRequest.from_message_short(message_obj) 33 | else: 34 | return JournalEntriesRequest.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "JournalEntriesRequest" 39 | -------------------------------------------------------------------------------- /dtc/message_types/journal_entry_add.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class JournalEntryAdd(BaseMessageType): 7 | def __init__(self, 8 | journal_entry=None, 9 | date_time=None): 10 | self.Type = MessageTypes.JOURNAL_ENTRY_ADD 11 | self.JournalEntry = journal_entry 12 | self.DateTime = date_time 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return JournalEntryAdd( 18 | journal_entry=packet[0], 19 | date_time=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return JournalEntryAdd( 25 | journal_entry=message_obj.get('JournalEntry'), 26 | date_time=message_obj.get('DateTime') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return JournalEntryAdd.from_message_short(message_obj) 33 | else: 34 | return JournalEntryAdd.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "JournalEntryAdd" 39 | -------------------------------------------------------------------------------- /dtc/message_types/journal_entry_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class JournalEntryResponse(BaseMessageType): 7 | def __init__(self, 8 | journal_entry=None, 9 | date_time=None, 10 | is_final_response=None): 11 | self.Type = MessageTypes.JOURNAL_ENTRY_RESPONSE 12 | self.JournalEntry = journal_entry 13 | self.DateTime = date_time 14 | self.IsFinalResponse = is_final_response 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return JournalEntryResponse( 20 | journal_entry=packet[0], 21 | date_time=packet[1], 22 | is_final_response=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return JournalEntryResponse( 28 | journal_entry=message_obj.get('JournalEntry'), 29 | date_time=message_obj.get('DateTime'), 30 | is_final_response=message_obj.get('IsFinalResponse') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return JournalEntryResponse.from_message_short(message_obj) 37 | else: 38 | return JournalEntryResponse.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "JournalEntryResponse" 43 | -------------------------------------------------------------------------------- /dtc/message_types/logoff.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class Logoff(BaseMessageType): 7 | def __init__(self, 8 | reason=None, 9 | do_not_reconnect=None): 10 | self.Type = MessageTypes.LOGOFF 11 | self.Reason = reason 12 | self.DoNotReconnect = do_not_reconnect 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return Logoff( 18 | reason=packet[0], 19 | do_not_reconnect=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return Logoff( 25 | reason=message_obj.get('Reason'), 26 | do_not_reconnect=message_obj.get('DoNotReconnect') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return Logoff.from_message_short(message_obj) 33 | else: 34 | return Logoff.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "Logoff" 39 | -------------------------------------------------------------------------------- /dtc/message_types/logon_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class LogonRequest(BaseMessageType): 7 | def __init__(self, 8 | protocol_version=None, 9 | username=None, 10 | password=None, 11 | general_text_data=None, 12 | integer_1=None, 13 | integer_2=None, 14 | heartbeat_interval_in_seconds=None, 15 | trade_mode=None, 16 | trade_account=None, 17 | hardware_identifier=None, 18 | client_name=None): 19 | self.Type = MessageTypes.LOGON_REQUEST 20 | self.ProtocolVersion = protocol_version 21 | self.Username = username 22 | self.Password = password 23 | self.GeneralTextData = general_text_data 24 | self.Integer_1 = integer_1 25 | self.Integer_2 = integer_2 26 | self.HeartbeatIntervalInSeconds = heartbeat_interval_in_seconds 27 | self.TradeMode = trade_mode 28 | self.TradeAccount = trade_account 29 | self.HardwareIdentifier = hardware_identifier 30 | self.ClientName = client_name 31 | 32 | @staticmethod 33 | def from_message_short(message_obj): 34 | packet = message_obj.get('F') 35 | return LogonRequest( 36 | protocol_version=packet[0], 37 | username=packet[1], 38 | password=packet[2], 39 | general_text_data=packet[3], 40 | integer_1=packet[4], 41 | integer_2=packet[5], 42 | heartbeat_interval_in_seconds=packet[6], 43 | trade_mode=packet[7], 44 | trade_account=packet[8], 45 | hardware_identifier=packet[9], 46 | client_name=packet[10] 47 | ) 48 | 49 | @staticmethod 50 | def from_message_long(message_obj): 51 | return LogonRequest( 52 | protocol_version=message_obj.get('ProtocolVersion'), 53 | username=message_obj.get('Username'), 54 | password=message_obj.get('Password'), 55 | general_text_data=message_obj.get('GeneralTextData'), 56 | integer_1=message_obj.get('Integer_1'), 57 | integer_2=message_obj.get('Integer_2'), 58 | heartbeat_interval_in_seconds=message_obj.get('HeartbeatIntervalInSeconds'), 59 | trade_mode=message_obj.get('TradeMode'), 60 | trade_account=message_obj.get('TradeAccount'), 61 | hardware_identifier=message_obj.get('HardwareIdentifier'), 62 | client_name=message_obj.get('ClientName') 63 | ) 64 | 65 | @staticmethod 66 | def from_message(message_obj): 67 | if 'F' in message_obj: 68 | return LogonRequest.from_message_short(message_obj) 69 | else: 70 | return LogonRequest.from_message_long(message_obj) 71 | 72 | @staticmethod 73 | def get_message_type_name(): 74 | return "LogonRequest" 75 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_feed_status.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataFeedStatus(BaseMessageType): 7 | def __init__(self, 8 | status=None): 9 | self.Type = MessageTypes.MARKET_DATA_FEED_STATUS 10 | self.Status = status 11 | 12 | @staticmethod 13 | def from_message_short(message_obj): 14 | packet = message_obj.get('F') 15 | return MarketDataFeedStatus( 16 | status=packet[0] 17 | ) 18 | 19 | @staticmethod 20 | def from_message_long(message_obj): 21 | return MarketDataFeedStatus( 22 | status=message_obj.get('Status') 23 | ) 24 | 25 | @staticmethod 26 | def from_message(message_obj): 27 | if 'F' in message_obj: 28 | return MarketDataFeedStatus.from_message_short(message_obj) 29 | else: 30 | return MarketDataFeedStatus.from_message_long(message_obj) 31 | 32 | @staticmethod 33 | def get_message_type_name(): 34 | return "MarketDataFeedStatus" 35 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_feed_symbol_status.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataFeedSymbolStatus(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | status=None): 10 | self.Type = MessageTypes.MARKET_DATA_FEED_SYMBOL_STATUS 11 | self.SymbolID = symbol_id 12 | self.Status = status 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return MarketDataFeedSymbolStatus( 18 | symbol_id=packet[0], 19 | status=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return MarketDataFeedSymbolStatus( 25 | symbol_id=message_obj.get('SymbolID'), 26 | status=message_obj.get('Status') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return MarketDataFeedSymbolStatus.from_message_short(message_obj) 33 | else: 34 | return MarketDataFeedSymbolStatus.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "MarketDataFeedSymbolStatus" 39 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataReject(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.MARKET_DATA_REJECT 11 | self.SymbolID = symbol_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return MarketDataReject( 18 | symbol_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return MarketDataReject( 25 | symbol_id=message_obj.get('SymbolID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return MarketDataReject.from_message_short(message_obj) 33 | else: 34 | return MarketDataReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "MarketDataReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataRequest(BaseMessageType): 7 | def __init__(self, 8 | request_action=None, 9 | symbol_id=None, 10 | symbol=None, 11 | exchange=None, 12 | interval_for_snapshot_updates_in_milliseconds=None): 13 | self.Type = MessageTypes.MARKET_DATA_REQUEST 14 | self.RequestAction = request_action 15 | self.SymbolID = symbol_id 16 | self.Symbol = symbol 17 | self.Exchange = exchange 18 | self.IntervalForSnapshotUpdatesInMilliseconds = interval_for_snapshot_updates_in_milliseconds 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return MarketDataRequest( 24 | request_action=packet[0], 25 | symbol_id=packet[1], 26 | symbol=packet[2], 27 | exchange=packet[3], 28 | interval_for_snapshot_updates_in_milliseconds=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return MarketDataRequest( 34 | request_action=message_obj.get('RequestAction'), 35 | symbol_id=message_obj.get('SymbolID'), 36 | symbol=message_obj.get('Symbol'), 37 | exchange=message_obj.get('Exchange'), 38 | interval_for_snapshot_updates_in_milliseconds=message_obj.get('IntervalForSnapshotUpdatesInMilliseconds') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return MarketDataRequest.from_message_short(message_obj) 45 | else: 46 | return MarketDataRequest.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "MarketDataRequest" 51 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_snapshot.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataSnapshot(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | session_settlement_price=None, 10 | session_open_price=None, 11 | session_high_price=None, 12 | session_low_price=None, 13 | session_volume=None, 14 | session_num_trades=None, 15 | open_interest=None, 16 | bid_price=None, 17 | ask_price=None, 18 | ask_quantity=None, 19 | bid_quantity=None, 20 | last_trade_price=None, 21 | last_trade_volume=None, 22 | last_trade_date_time=None, 23 | bid_ask_date_time=None, 24 | session_settlement_date_time=None, 25 | trading_session_date=None, 26 | trading_status=None, 27 | market_depth_update_date_time=None): 28 | self.Type = MessageTypes.MARKET_DATA_SNAPSHOT 29 | self.SymbolID = symbol_id 30 | self.SessionSettlementPrice = session_settlement_price 31 | self.SessionOpenPrice = session_open_price 32 | self.SessionHighPrice = session_high_price 33 | self.SessionLowPrice = session_low_price 34 | self.SessionVolume = session_volume 35 | self.SessionNumTrades = session_num_trades 36 | self.OpenInterest = open_interest 37 | self.BidPrice = bid_price 38 | self.AskPrice = ask_price 39 | self.AskQuantity = ask_quantity 40 | self.BidQuantity = bid_quantity 41 | self.LastTradePrice = last_trade_price 42 | self.LastTradeVolume = last_trade_volume 43 | self.LastTradeDateTime = last_trade_date_time 44 | self.BidAskDateTime = bid_ask_date_time 45 | self.SessionSettlementDateTime = session_settlement_date_time 46 | self.TradingSessionDate = trading_session_date 47 | self.TradingStatus = trading_status 48 | self.MarketDepthUpdateDateTime = market_depth_update_date_time 49 | 50 | @staticmethod 51 | def from_message_short(message_obj): 52 | packet = message_obj.get('F') 53 | return MarketDataSnapshot( 54 | symbol_id=packet[0], 55 | session_settlement_price=packet[1], 56 | session_open_price=packet[2], 57 | session_high_price=packet[3], 58 | session_low_price=packet[4], 59 | session_volume=packet[5], 60 | session_num_trades=packet[6], 61 | open_interest=packet[7], 62 | bid_price=packet[8], 63 | ask_price=packet[9], 64 | ask_quantity=packet[10], 65 | bid_quantity=packet[11], 66 | last_trade_price=packet[12], 67 | last_trade_volume=packet[13], 68 | last_trade_date_time=packet[14], 69 | bid_ask_date_time=packet[15], 70 | session_settlement_date_time=packet[16], 71 | trading_session_date=packet[17], 72 | trading_status=packet[18], 73 | market_depth_update_date_time=packet[19] 74 | ) 75 | 76 | @staticmethod 77 | def from_message_long(message_obj): 78 | return MarketDataSnapshot( 79 | symbol_id=message_obj.get('SymbolID'), 80 | session_settlement_price=message_obj.get('SessionSettlementPrice'), 81 | session_open_price=message_obj.get('SessionOpenPrice'), 82 | session_high_price=message_obj.get('SessionHighPrice'), 83 | session_low_price=message_obj.get('SessionLowPrice'), 84 | session_volume=message_obj.get('SessionVolume'), 85 | session_num_trades=message_obj.get('SessionNumTrades'), 86 | open_interest=message_obj.get('OpenInterest'), 87 | bid_price=message_obj.get('BidPrice'), 88 | ask_price=message_obj.get('AskPrice'), 89 | ask_quantity=message_obj.get('AskQuantity'), 90 | bid_quantity=message_obj.get('BidQuantity'), 91 | last_trade_price=message_obj.get('LastTradePrice'), 92 | last_trade_volume=message_obj.get('LastTradeVolume'), 93 | last_trade_date_time=message_obj.get('LastTradeDateTime'), 94 | bid_ask_date_time=message_obj.get('BidAskDateTime'), 95 | session_settlement_date_time=message_obj.get('SessionSettlementDateTime'), 96 | trading_session_date=message_obj.get('TradingSessionDate'), 97 | trading_status=message_obj.get('TradingStatus'), 98 | market_depth_update_date_time=message_obj.get('MarketDepthUpdateDateTime') 99 | ) 100 | 101 | @staticmethod 102 | def from_message(message_obj): 103 | if 'F' in message_obj: 104 | return MarketDataSnapshot.from_message_short(message_obj) 105 | else: 106 | return MarketDataSnapshot.from_message_long(message_obj) 107 | 108 | @staticmethod 109 | def get_message_type_name(): 110 | return "MarketDataSnapshot" 111 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_snapshot_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataSnapshotInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | session_settlement_price=None, 10 | session_open_price=None, 11 | session_high_price=None, 12 | session_low_price=None, 13 | session_volume=None, 14 | session_num_trades=None, 15 | open_interest=None, 16 | bid_price=None, 17 | ask_price=None, 18 | ask_quantity=None, 19 | bid_quantity=None, 20 | last_trade_price=None, 21 | last_trade_volume=None, 22 | last_trade_date_time=None, 23 | bid_ask_date_time=None, 24 | session_settlement_date_time=None, 25 | trading_session_date=None, 26 | trading_status=None): 27 | self.Type = MessageTypes.MARKET_DATA_SNAPSHOT_INT 28 | self.SymbolID = symbol_id 29 | self.SessionSettlementPrice = session_settlement_price 30 | self.SessionOpenPrice = session_open_price 31 | self.SessionHighPrice = session_high_price 32 | self.SessionLowPrice = session_low_price 33 | self.SessionVolume = session_volume 34 | self.SessionNumTrades = session_num_trades 35 | self.OpenInterest = open_interest 36 | self.BidPrice = bid_price 37 | self.AskPrice = ask_price 38 | self.AskQuantity = ask_quantity 39 | self.BidQuantity = bid_quantity 40 | self.LastTradePrice = last_trade_price 41 | self.LastTradeVolume = last_trade_volume 42 | self.LastTradeDateTime = last_trade_date_time 43 | self.BidAskDateTime = bid_ask_date_time 44 | self.SessionSettlementDateTime = session_settlement_date_time 45 | self.TradingSessionDate = trading_session_date 46 | self.TradingStatus = trading_status 47 | 48 | @staticmethod 49 | def from_message_short(message_obj): 50 | packet = message_obj.get('F') 51 | return MarketDataSnapshotInt( 52 | symbol_id=packet[0], 53 | session_settlement_price=packet[1], 54 | session_open_price=packet[2], 55 | session_high_price=packet[3], 56 | session_low_price=packet[4], 57 | session_volume=packet[5], 58 | session_num_trades=packet[6], 59 | open_interest=packet[7], 60 | bid_price=packet[8], 61 | ask_price=packet[9], 62 | ask_quantity=packet[10], 63 | bid_quantity=packet[11], 64 | last_trade_price=packet[12], 65 | last_trade_volume=packet[13], 66 | last_trade_date_time=packet[14], 67 | bid_ask_date_time=packet[15], 68 | session_settlement_date_time=packet[16], 69 | trading_session_date=packet[17], 70 | trading_status=packet[18] 71 | ) 72 | 73 | @staticmethod 74 | def from_message_long(message_obj): 75 | return MarketDataSnapshotInt( 76 | symbol_id=message_obj.get('SymbolID'), 77 | session_settlement_price=message_obj.get('SessionSettlementPrice'), 78 | session_open_price=message_obj.get('SessionOpenPrice'), 79 | session_high_price=message_obj.get('SessionHighPrice'), 80 | session_low_price=message_obj.get('SessionLowPrice'), 81 | session_volume=message_obj.get('SessionVolume'), 82 | session_num_trades=message_obj.get('SessionNumTrades'), 83 | open_interest=message_obj.get('OpenInterest'), 84 | bid_price=message_obj.get('BidPrice'), 85 | ask_price=message_obj.get('AskPrice'), 86 | ask_quantity=message_obj.get('AskQuantity'), 87 | bid_quantity=message_obj.get('BidQuantity'), 88 | last_trade_price=message_obj.get('LastTradePrice'), 89 | last_trade_volume=message_obj.get('LastTradeVolume'), 90 | last_trade_date_time=message_obj.get('LastTradeDateTime'), 91 | bid_ask_date_time=message_obj.get('BidAskDateTime'), 92 | session_settlement_date_time=message_obj.get('SessionSettlementDateTime'), 93 | trading_session_date=message_obj.get('TradingSessionDate'), 94 | trading_status=message_obj.get('TradingStatus') 95 | ) 96 | 97 | @staticmethod 98 | def from_message(message_obj): 99 | if 'F' in message_obj: 100 | return MarketDataSnapshotInt.from_message_short(message_obj) 101 | else: 102 | return MarketDataSnapshotInt.from_message_long(message_obj) 103 | 104 | @staticmethod 105 | def get_message_type_name(): 106 | return "MarketDataSnapshotInt" 107 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_bid_ask.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateBidAsk(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | bid_price=None, 10 | bid_quantity=None, 11 | ask_price=None, 12 | ask_quantity=None, 13 | date_time=None): 14 | self.Type = MessageTypes.MARKET_DATA_UPDATE_BID_ASK 15 | self.SymbolID = symbol_id 16 | self.BidPrice = bid_price 17 | self.BidQuantity = bid_quantity 18 | self.AskPrice = ask_price 19 | self.AskQuantity = ask_quantity 20 | self.DateTime = date_time 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return MarketDataUpdateBidAsk( 26 | symbol_id=packet[0], 27 | bid_price=packet[1], 28 | bid_quantity=packet[2], 29 | ask_price=packet[3], 30 | ask_quantity=packet[4], 31 | date_time=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return MarketDataUpdateBidAsk( 37 | symbol_id=message_obj.get('SymbolID'), 38 | bid_price=message_obj.get('BidPrice'), 39 | bid_quantity=message_obj.get('BidQuantity'), 40 | ask_price=message_obj.get('AskPrice'), 41 | ask_quantity=message_obj.get('AskQuantity'), 42 | date_time=message_obj.get('DateTime') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return MarketDataUpdateBidAsk.from_message_short(message_obj) 49 | else: 50 | return MarketDataUpdateBidAsk.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "MarketDataUpdateBidAsk" 55 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_bid_ask_compact.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateBidAskCompact(BaseMessageType): 7 | def __init__(self, 8 | bid_price=None, 9 | bid_quantity=None, 10 | ask_price=None, 11 | ask_quantity=None, 12 | date_time=None, 13 | symbol_id=None): 14 | self.Type = MessageTypes.MARKET_DATA_UPDATE_BID_ASK_COMPACT 15 | self.BidPrice = bid_price 16 | self.BidQuantity = bid_quantity 17 | self.AskPrice = ask_price 18 | self.AskQuantity = ask_quantity 19 | self.DateTime = date_time 20 | self.SymbolID = symbol_id 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return MarketDataUpdateBidAskCompact( 26 | symbol_id=packet[0], 27 | bid_price=packet[1], 28 | bid_quantity=packet[2], 29 | ask_price=packet[3], 30 | ask_quantity=packet[4], 31 | date_time=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return MarketDataUpdateBidAskCompact( 37 | bid_price=message_obj.get('BidPrice'), 38 | bid_quantity=message_obj.get('BidQuantity'), 39 | ask_price=message_obj.get('AskPrice'), 40 | ask_quantity=message_obj.get('AskQuantity'), 41 | date_time=message_obj.get('DateTime'), 42 | symbol_id=message_obj.get('SymbolID') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return MarketDataUpdateBidAskCompact.from_message_short(message_obj) 49 | else: 50 | return MarketDataUpdateBidAskCompact.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "MarketDataUpdateBidAskCompact" 55 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_bid_ask_float_with_milliseconds.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateBidAskFloatWithMilliseconds(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | bid_price=None, 10 | bid_quantity=None, 11 | ask_price=None, 12 | ask_quantity=None, 13 | date_time=None): 14 | self.Type = MessageTypes.MARKET_DATA_UPDATE_BID_ASK_FLOAT_WITH_MILLISECONDS 15 | self.SymbolID = symbol_id 16 | self.BidPrice = bid_price 17 | self.BidQuantity = bid_quantity 18 | self.AskPrice = ask_price 19 | self.AskQuantity = ask_quantity 20 | self.DateTime = date_time 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return MarketDataUpdateBidAskFloatWithMilliseconds( 26 | symbol_id=packet[0], 27 | bid_price=packet[1], 28 | bid_quantity=packet[2], 29 | ask_price=packet[3], 30 | ask_quantity=packet[4], 31 | date_time=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return MarketDataUpdateBidAskFloatWithMilliseconds( 37 | symbol_id=message_obj.get('SymbolID'), 38 | bid_price=message_obj.get('BidPrice'), 39 | bid_quantity=message_obj.get('BidQuantity'), 40 | ask_price=message_obj.get('AskPrice'), 41 | ask_quantity=message_obj.get('AskQuantity'), 42 | date_time=message_obj.get('DateTime') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return MarketDataUpdateBidAskFloatWithMilliseconds.from_message_short(message_obj) 49 | else: 50 | return MarketDataUpdateBidAskFloatWithMilliseconds.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "MarketDataUpdateBidAskFloatWithMilliseconds" 55 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_bid_ask_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateBidAskInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | bid_price=None, 10 | bid_quantity=None, 11 | ask_price=None, 12 | ask_quantity=None, 13 | date_time=None): 14 | self.Type = MessageTypes.MARKET_DATA_UPDATE_BID_ASK_INT 15 | self.SymbolID = symbol_id 16 | self.BidPrice = bid_price 17 | self.BidQuantity = bid_quantity 18 | self.AskPrice = ask_price 19 | self.AskQuantity = ask_quantity 20 | self.DateTime = date_time 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return MarketDataUpdateBidAskInt( 26 | symbol_id=packet[0], 27 | bid_price=packet[1], 28 | bid_quantity=packet[2], 29 | ask_price=packet[3], 30 | ask_quantity=packet[4], 31 | date_time=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return MarketDataUpdateBidAskInt( 37 | symbol_id=message_obj.get('SymbolID'), 38 | bid_price=message_obj.get('BidPrice'), 39 | bid_quantity=message_obj.get('BidQuantity'), 40 | ask_price=message_obj.get('AskPrice'), 41 | ask_quantity=message_obj.get('AskQuantity'), 42 | date_time=message_obj.get('DateTime') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return MarketDataUpdateBidAskInt.from_message_short(message_obj) 49 | else: 50 | return MarketDataUpdateBidAskInt.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "MarketDataUpdateBidAskInt" 55 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_last_trade_snapshot.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateLastTradeSnapshot(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | last_trade_price=None, 10 | last_trade_volume=None, 11 | last_trade_date_time=None): 12 | self.Type = MessageTypes.MARKET_DATA_UPDATE_LAST_TRADE_SNAPSHOT 13 | self.SymbolID = symbol_id 14 | self.LastTradePrice = last_trade_price 15 | self.LastTradeVolume = last_trade_volume 16 | self.LastTradeDateTime = last_trade_date_time 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return MarketDataUpdateLastTradeSnapshot( 22 | symbol_id=packet[0], 23 | last_trade_price=packet[1], 24 | last_trade_volume=packet[2], 25 | last_trade_date_time=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return MarketDataUpdateLastTradeSnapshot( 31 | symbol_id=message_obj.get('SymbolID'), 32 | last_trade_price=message_obj.get('LastTradePrice'), 33 | last_trade_volume=message_obj.get('LastTradeVolume'), 34 | last_trade_date_time=message_obj.get('LastTradeDateTime') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return MarketDataUpdateLastTradeSnapshot.from_message_short(message_obj) 41 | else: 42 | return MarketDataUpdateLastTradeSnapshot.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "MarketDataUpdateLastTradeSnapshot" 47 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_open_interest.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateOpenInterest(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | open_interest=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_OPEN_INTEREST 12 | self.SymbolID = symbol_id 13 | self.OpenInterest = open_interest 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateOpenInterest( 20 | symbol_id=packet[0], 21 | open_interest=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateOpenInterest( 28 | symbol_id=message_obj.get('SymbolID'), 29 | open_interest=message_obj.get('OpenInterest'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateOpenInterest.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateOpenInterest.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateOpenInterest" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_high.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionHigh(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_HIGH 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionHigh( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionHigh( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionHigh.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionHigh.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionHigh" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_high_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionHighInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_HIGH_INT 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionHighInt( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionHighInt( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionHighInt.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionHighInt.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionHighInt" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_low.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionLow(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_LOW 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionLow( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionLow( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionLow.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionLow.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionLow" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_low_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionLowInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_LOW_INT 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionLowInt( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionLowInt( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionLowInt.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionLowInt.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionLowInt" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_num_trades.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionNumTrades(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | num_trades=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_NUM_TRADES 12 | self.SymbolID = symbol_id 13 | self.NumTrades = num_trades 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionNumTrades( 20 | symbol_id=packet[0], 21 | num_trades=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionNumTrades( 28 | symbol_id=message_obj.get('SymbolID'), 29 | num_trades=message_obj.get('NumTrades'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionNumTrades.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionNumTrades.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionNumTrades" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_open.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionOpen(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_OPEN 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionOpen( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionOpen( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionOpen.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionOpen.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionOpen" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_open_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionOpenInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | trading_session_date=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_OPEN_INT 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.TradingSessionDate = trading_session_date 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionOpenInt( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | trading_session_date=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionOpenInt( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | trading_session_date=message_obj.get('TradingSessionDate') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionOpenInt.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionOpenInt.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionOpenInt" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_settlement.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionSettlement(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | date_time=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_SETTLEMENT 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.DateTime = date_time 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionSettlement( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | date_time=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionSettlement( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | date_time=message_obj.get('DateTime') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionSettlement.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionSettlement.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionSettlement" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_settlement_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionSettlementInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | date_time=None): 11 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_SETTLEMENT_INT 12 | self.SymbolID = symbol_id 13 | self.Price = price 14 | self.DateTime = date_time 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return MarketDataUpdateSessionSettlementInt( 20 | symbol_id=packet[0], 21 | price=packet[1], 22 | date_time=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return MarketDataUpdateSessionSettlementInt( 28 | symbol_id=message_obj.get('SymbolID'), 29 | price=message_obj.get('Price'), 30 | date_time=message_obj.get('DateTime') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return MarketDataUpdateSessionSettlementInt.from_message_short(message_obj) 37 | else: 38 | return MarketDataUpdateSessionSettlementInt.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "MarketDataUpdateSessionSettlementInt" 43 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_session_volume.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateSessionVolume(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | volume=None, 10 | trading_session_date=None, 11 | is_final_session_volume=None): 12 | self.Type = MessageTypes.MARKET_DATA_UPDATE_SESSION_VOLUME 13 | self.SymbolID = symbol_id 14 | self.Volume = volume 15 | self.TradingSessionDate = trading_session_date 16 | self.IsFinalSessionVolume = is_final_session_volume 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return MarketDataUpdateSessionVolume( 22 | symbol_id=packet[0], 23 | volume=packet[1], 24 | trading_session_date=packet[2], 25 | is_final_session_volume=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return MarketDataUpdateSessionVolume( 31 | symbol_id=message_obj.get('SymbolID'), 32 | volume=message_obj.get('Volume'), 33 | trading_session_date=message_obj.get('TradingSessionDate'), 34 | is_final_session_volume=message_obj.get('IsFinalSessionVolume') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return MarketDataUpdateSessionVolume.from_message_short(message_obj) 41 | else: 42 | return MarketDataUpdateSessionVolume.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "MarketDataUpdateSessionVolume" 47 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_trade.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateTrade(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | at_bid_or_ask=None, 10 | price=None, 11 | volume=None, 12 | date_time=None): 13 | self.Type = MessageTypes.MARKET_DATA_UPDATE_TRADE 14 | self.SymbolID = symbol_id 15 | self.AtBidOrAsk = at_bid_or_ask 16 | self.Price = price 17 | self.Volume = volume 18 | self.DateTime = date_time 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return MarketDataUpdateTrade( 24 | symbol_id=packet[0], 25 | at_bid_or_ask=packet[1], 26 | price=packet[2], 27 | volume=packet[3], 28 | date_time=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return MarketDataUpdateTrade( 34 | symbol_id=message_obj.get('SymbolID'), 35 | at_bid_or_ask=message_obj.get('AtBidOrAsk'), 36 | price=message_obj.get('Price'), 37 | volume=message_obj.get('Volume'), 38 | date_time=message_obj.get('DateTime') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return MarketDataUpdateTrade.from_message_short(message_obj) 45 | else: 46 | return MarketDataUpdateTrade.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "MarketDataUpdateTrade" 51 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_trade_compact.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateTradeCompact(BaseMessageType): 7 | def __init__(self, 8 | price=None, 9 | volume=None, 10 | date_time=None, 11 | symbol_id=None, 12 | at_bid_or_ask=None): 13 | self.Type = MessageTypes.MARKET_DATA_UPDATE_TRADE_COMPACT 14 | self.Price = price 15 | self.Volume = volume 16 | self.DateTime = date_time 17 | self.SymbolID = symbol_id 18 | self.AtBidOrAsk = at_bid_or_ask 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return MarketDataUpdateTradeCompact( 24 | symbol_id=packet[0], 25 | at_bid_or_ask=packet[1], 26 | price=packet[2], 27 | volume=packet[3], 28 | date_time=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return MarketDataUpdateTradeCompact( 34 | price=message_obj.get('Price'), 35 | volume=message_obj.get('Volume'), 36 | date_time=message_obj.get('DateTime'), 37 | symbol_id=message_obj.get('SymbolID'), 38 | at_bid_or_ask=message_obj.get('AtBidOrAsk') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return MarketDataUpdateTradeCompact.from_message_short(message_obj) 45 | else: 46 | return MarketDataUpdateTradeCompact.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "MarketDataUpdateTradeCompact" 51 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_trade_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateTradeInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | at_bid_or_ask=None, 10 | price=None, 11 | volume=None, 12 | date_time=None): 13 | self.Type = MessageTypes.MARKET_DATA_UPDATE_TRADE_INT 14 | self.SymbolID = symbol_id 15 | self.AtBidOrAsk = at_bid_or_ask 16 | self.Price = price 17 | self.Volume = volume 18 | self.DateTime = date_time 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return MarketDataUpdateTradeInt( 24 | symbol_id=packet[0], 25 | at_bid_or_ask=packet[1], 26 | price=packet[2], 27 | volume=packet[3], 28 | date_time=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return MarketDataUpdateTradeInt( 34 | symbol_id=message_obj.get('SymbolID'), 35 | at_bid_or_ask=message_obj.get('AtBidOrAsk'), 36 | price=message_obj.get('Price'), 37 | volume=message_obj.get('Volume'), 38 | date_time=message_obj.get('DateTime') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return MarketDataUpdateTradeInt.from_message_short(message_obj) 45 | else: 46 | return MarketDataUpdateTradeInt.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "MarketDataUpdateTradeInt" 51 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_trade_no_timestamp.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateTradeNoTimestamp(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | volume=None, 11 | at_bid_or_ask=None, 12 | unbundled_trade_indicator=None): 13 | self.Type = MessageTypes.MARKET_DATA_UPDATE_TRADE_NO_TIMESTAMP 14 | self.SymbolID = symbol_id 15 | self.Price = price 16 | self.Volume = volume 17 | self.AtBidOrAsk = at_bid_or_ask 18 | self.UnbundledTradeIndicator = unbundled_trade_indicator 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return MarketDataUpdateTradeNoTimestamp( 24 | symbol_id=packet[0], 25 | price=packet[1], 26 | volume=packet[2], 27 | at_bid_or_ask=packet[3], 28 | unbundled_trade_indicator=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return MarketDataUpdateTradeNoTimestamp( 34 | symbol_id=message_obj.get('SymbolID'), 35 | price=message_obj.get('Price'), 36 | volume=message_obj.get('Volume'), 37 | at_bid_or_ask=message_obj.get('AtBidOrAsk'), 38 | unbundled_trade_indicator=message_obj.get('UnbundledTradeIndicator') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return MarketDataUpdateTradeNoTimestamp.from_message_short(message_obj) 45 | else: 46 | return MarketDataUpdateTradeNoTimestamp.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "MarketDataUpdateTradeNoTimestamp" 51 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_trade_with_unbundled_indicator.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateTradeWithUnbundledIndicator(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | at_bid_or_ask=None, 10 | unbundled_trade_indicator=None, 11 | sale_condition=None, 12 | reserve_1=None, 13 | reserve_2=None, 14 | price=None, 15 | volume=None, 16 | reserve_3=None, 17 | date_time=None): 18 | self.Type = MessageTypes.MARKET_DATA_UPDATE_TRADE_WITH_UNBUNDLED_INDICATOR 19 | self.SymbolID = symbol_id 20 | self.AtBidOrAsk = at_bid_or_ask 21 | self.UnbundledTradeIndicator = unbundled_trade_indicator 22 | self.SaleCondition = sale_condition 23 | self.Reserve_1 = reserve_1 24 | self.Reserve_2 = reserve_2 25 | self.Price = price 26 | self.Volume = volume 27 | self.Reserve_3 = reserve_3 28 | self.DateTime = date_time 29 | 30 | @staticmethod 31 | def from_message_short(message_obj): 32 | packet = message_obj.get('F') 33 | return MarketDataUpdateTradeWithUnbundledIndicator( 34 | symbol_id=packet[0], 35 | at_bid_or_ask=packet[1], 36 | unbundled_trade_indicator=packet[2], 37 | sale_condition=packet[3], 38 | reserve_1=packet[4], 39 | reserve_2=packet[5], 40 | price=packet[6], 41 | volume=packet[7], 42 | reserve_3=packet[8], 43 | date_time=packet[9] 44 | ) 45 | 46 | @staticmethod 47 | def from_message_long(message_obj): 48 | return MarketDataUpdateTradeWithUnbundledIndicator( 49 | symbol_id=message_obj.get('SymbolID'), 50 | at_bid_or_ask=message_obj.get('AtBidOrAsk'), 51 | unbundled_trade_indicator=message_obj.get('UnbundledTradeIndicator'), 52 | sale_condition=message_obj.get('SaleCondition'), 53 | reserve_1=message_obj.get('Reserve_1'), 54 | reserve_2=message_obj.get('Reserve_2'), 55 | price=message_obj.get('Price'), 56 | volume=message_obj.get('Volume'), 57 | reserve_3=message_obj.get('Reserve_3'), 58 | date_time=message_obj.get('DateTime') 59 | ) 60 | 61 | @staticmethod 62 | def from_message(message_obj): 63 | if 'F' in message_obj: 64 | return MarketDataUpdateTradeWithUnbundledIndicator.from_message_short(message_obj) 65 | else: 66 | return MarketDataUpdateTradeWithUnbundledIndicator.from_message_long(message_obj) 67 | 68 | @staticmethod 69 | def get_message_type_name(): 70 | return "MarketDataUpdateTradeWithUnbundledIndicator" 71 | -------------------------------------------------------------------------------- /dtc/message_types/market_data_update_trading_session_date.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDataUpdateTradingSessionDate(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | date=None): 10 | self.Type = MessageTypes.MARKET_DATA_UPDATE_TRADING_SESSION_DATE 11 | self.SymbolID = symbol_id 12 | self.Date = date 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return MarketDataUpdateTradingSessionDate( 18 | symbol_id=packet[0], 19 | date=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return MarketDataUpdateTradingSessionDate( 25 | symbol_id=message_obj.get('SymbolID'), 26 | date=message_obj.get('Date') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return MarketDataUpdateTradingSessionDate.from_message_short(message_obj) 33 | else: 34 | return MarketDataUpdateTradingSessionDate.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "MarketDataUpdateTradingSessionDate" 39 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthReject(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.MARKET_DEPTH_REJECT 11 | self.SymbolID = symbol_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return MarketDepthReject( 18 | symbol_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return MarketDepthReject( 25 | symbol_id=message_obj.get('SymbolID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return MarketDepthReject.from_message_short(message_obj) 33 | else: 34 | return MarketDepthReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "MarketDepthReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthRequest(BaseMessageType): 7 | def __init__(self, 8 | request_action=None, 9 | symbol_id=None, 10 | symbol=None, 11 | exchange=None, 12 | num_levels=None): 13 | self.Type = MessageTypes.MARKET_DEPTH_REQUEST 14 | self.RequestAction = request_action 15 | self.SymbolID = symbol_id 16 | self.Symbol = symbol 17 | self.Exchange = exchange 18 | self.NumLevels = num_levels 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return MarketDepthRequest( 24 | request_action=packet[0], 25 | symbol_id=packet[1], 26 | symbol=packet[2], 27 | exchange=packet[3], 28 | num_levels=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return MarketDepthRequest( 34 | request_action=message_obj.get('RequestAction'), 35 | symbol_id=message_obj.get('SymbolID'), 36 | symbol=message_obj.get('Symbol'), 37 | exchange=message_obj.get('Exchange'), 38 | num_levels=message_obj.get('NumLevels') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return MarketDepthRequest.from_message_short(message_obj) 45 | else: 46 | return MarketDepthRequest.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "MarketDepthRequest" 51 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_snapshot_level.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthSnapshotLevel(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | side=None, 10 | price=None, 11 | quantity=None, 12 | level=None, 13 | is_first_message_in_batch=None, 14 | is_last_message_in_batch=None, 15 | date_time=None, 16 | num_orders=None): 17 | self.Type = MessageTypes.MARKET_DEPTH_SNAPSHOT_LEVEL 18 | self.SymbolID = symbol_id 19 | self.Side = side 20 | self.Price = price 21 | self.Quantity = quantity 22 | self.Level = level 23 | self.IsFirstMessageInBatch = is_first_message_in_batch 24 | self.IsLastMessageInBatch = is_last_message_in_batch 25 | self.DateTime = date_time 26 | self.NumOrders = num_orders 27 | 28 | @staticmethod 29 | def from_message_short(message_obj): 30 | packet = message_obj.get('F') 31 | return MarketDepthSnapshotLevel( 32 | symbol_id=packet[0], 33 | side=packet[1], 34 | price=packet[2], 35 | quantity=packet[3], 36 | level=packet[4], 37 | is_first_message_in_batch=packet[5], 38 | is_last_message_in_batch=packet[6], 39 | date_time=packet[7], 40 | num_orders=packet[8] 41 | ) 42 | 43 | @staticmethod 44 | def from_message_long(message_obj): 45 | return MarketDepthSnapshotLevel( 46 | symbol_id=message_obj.get('SymbolID'), 47 | side=message_obj.get('Side'), 48 | price=message_obj.get('Price'), 49 | quantity=message_obj.get('Quantity'), 50 | level=message_obj.get('Level'), 51 | is_first_message_in_batch=message_obj.get('IsFirstMessageInBatch'), 52 | is_last_message_in_batch=message_obj.get('IsLastMessageInBatch'), 53 | date_time=message_obj.get('DateTime'), 54 | num_orders=message_obj.get('NumOrders') 55 | ) 56 | 57 | @staticmethod 58 | def from_message(message_obj): 59 | if 'F' in message_obj: 60 | return MarketDepthSnapshotLevel.from_message_short(message_obj) 61 | else: 62 | return MarketDepthSnapshotLevel.from_message_long(message_obj) 63 | 64 | @staticmethod 65 | def get_message_type_name(): 66 | return "MarketDepthSnapshotLevel" 67 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_snapshot_level_float.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthSnapshotLevelFloat(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | quantity=None, 11 | num_orders=None, 12 | level=None, 13 | side=None, 14 | final_update_in_batch=None): 15 | self.Type = MessageTypes.MARKET_DEPTH_SNAPSHOT_LEVEL_FLOAT 16 | self.SymbolID = symbol_id 17 | self.Price = price 18 | self.Quantity = quantity 19 | self.NumOrders = num_orders 20 | self.Level = level 21 | self.Side = side 22 | self.FinalUpdateInBatch = final_update_in_batch 23 | 24 | @staticmethod 25 | def from_message_short(message_obj): 26 | packet = message_obj.get('F') 27 | return MarketDepthSnapshotLevelFloat( 28 | symbol_id=packet[0], 29 | price=packet[1], 30 | quantity=packet[2], 31 | num_orders=packet[3], 32 | level=packet[4], 33 | side=packet[5], 34 | final_update_in_batch=packet[6] 35 | ) 36 | 37 | @staticmethod 38 | def from_message_long(message_obj): 39 | return MarketDepthSnapshotLevelFloat( 40 | symbol_id=message_obj.get('SymbolID'), 41 | price=message_obj.get('Price'), 42 | quantity=message_obj.get('Quantity'), 43 | num_orders=message_obj.get('NumOrders'), 44 | level=message_obj.get('Level'), 45 | side=message_obj.get('Side'), 46 | final_update_in_batch=message_obj.get('FinalUpdateInBatch') 47 | ) 48 | 49 | @staticmethod 50 | def from_message(message_obj): 51 | if 'F' in message_obj: 52 | return MarketDepthSnapshotLevelFloat.from_message_short(message_obj) 53 | else: 54 | return MarketDepthSnapshotLevelFloat.from_message_long(message_obj) 55 | 56 | @staticmethod 57 | def get_message_type_name(): 58 | return "MarketDepthSnapshotLevelFloat" 59 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_snapshot_level_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthSnapshotLevelInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | side=None, 10 | price=None, 11 | quantity=None, 12 | level=None, 13 | is_first_message_in_batch=None, 14 | is_last_message_in_batch=None, 15 | date_time=None, 16 | num_orders=None): 17 | self.Type = MessageTypes.MARKET_DEPTH_SNAPSHOT_LEVEL_INT 18 | self.SymbolID = symbol_id 19 | self.Side = side 20 | self.Price = price 21 | self.Quantity = quantity 22 | self.Level = level 23 | self.IsFirstMessageInBatch = is_first_message_in_batch 24 | self.IsLastMessageInBatch = is_last_message_in_batch 25 | self.DateTime = date_time 26 | self.NumOrders = num_orders 27 | 28 | @staticmethod 29 | def from_message_short(message_obj): 30 | packet = message_obj.get('F') 31 | return MarketDepthSnapshotLevelInt( 32 | symbol_id=packet[0], 33 | side=packet[1], 34 | price=packet[2], 35 | quantity=packet[3], 36 | level=packet[4], 37 | is_first_message_in_batch=packet[5], 38 | is_last_message_in_batch=packet[6], 39 | date_time=packet[7], 40 | num_orders=packet[8] 41 | ) 42 | 43 | @staticmethod 44 | def from_message_long(message_obj): 45 | return MarketDepthSnapshotLevelInt( 46 | symbol_id=message_obj.get('SymbolID'), 47 | side=message_obj.get('Side'), 48 | price=message_obj.get('Price'), 49 | quantity=message_obj.get('Quantity'), 50 | level=message_obj.get('Level'), 51 | is_first_message_in_batch=message_obj.get('IsFirstMessageInBatch'), 52 | is_last_message_in_batch=message_obj.get('IsLastMessageInBatch'), 53 | date_time=message_obj.get('DateTime'), 54 | num_orders=message_obj.get('NumOrders') 55 | ) 56 | 57 | @staticmethod 58 | def from_message(message_obj): 59 | if 'F' in message_obj: 60 | return MarketDepthSnapshotLevelInt.from_message_short(message_obj) 61 | else: 62 | return MarketDepthSnapshotLevelInt.from_message_long(message_obj) 63 | 64 | @staticmethod 65 | def get_message_type_name(): 66 | return "MarketDepthSnapshotLevelInt" 67 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_update_level.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthUpdateLevel(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | side=None, 10 | price=None, 11 | quantity=None, 12 | update_type=None, 13 | date_time=None, 14 | num_orders=None): 15 | self.Type = MessageTypes.MARKET_DEPTH_UPDATE_LEVEL 16 | self.SymbolID = symbol_id 17 | self.Side = side 18 | self.Price = price 19 | self.Quantity = quantity 20 | self.UpdateType = update_type 21 | self.DateTime = date_time 22 | self.NumOrders = num_orders 23 | 24 | @staticmethod 25 | def from_message_short(message_obj): 26 | packet = message_obj.get('F') 27 | return MarketDepthUpdateLevel( 28 | symbol_id=packet[0], 29 | side=packet[1], 30 | price=packet[2], 31 | quantity=packet[3], 32 | update_type=packet[4], 33 | date_time=packet[5], 34 | num_orders=packet[6] 35 | ) 36 | 37 | @staticmethod 38 | def from_message_long(message_obj): 39 | return MarketDepthUpdateLevel( 40 | symbol_id=message_obj.get('SymbolID'), 41 | side=message_obj.get('Side'), 42 | price=message_obj.get('Price'), 43 | quantity=message_obj.get('Quantity'), 44 | update_type=message_obj.get('UpdateType'), 45 | date_time=message_obj.get('DateTime'), 46 | num_orders=message_obj.get('NumOrders') 47 | ) 48 | 49 | @staticmethod 50 | def from_message(message_obj): 51 | if 'F' in message_obj: 52 | return MarketDepthUpdateLevel.from_message_short(message_obj) 53 | else: 54 | return MarketDepthUpdateLevel.from_message_long(message_obj) 55 | 56 | @staticmethod 57 | def get_message_type_name(): 58 | return "MarketDepthUpdateLevel" 59 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_update_level_float_with_milliseconds.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthUpdateLevelFloatWithMilliseconds(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | date_time=None, 10 | price=None, 11 | quantity=None, 12 | side=None, 13 | update_type=None, 14 | num_orders=None, 15 | final_update_in_batch=None): 16 | self.Type = MessageTypes.MARKET_DEPTH_UPDATE_LEVEL_FLOAT_WITH_MILLISECONDS 17 | self.SymbolID = symbol_id 18 | self.DateTime = date_time 19 | self.Price = price 20 | self.Quantity = quantity 21 | self.Side = side 22 | self.UpdateType = update_type 23 | self.NumOrders = num_orders 24 | self.FinalUpdateInBatch = final_update_in_batch 25 | 26 | @staticmethod 27 | def from_message_short(message_obj): 28 | packet = message_obj.get('F') 29 | return MarketDepthUpdateLevelFloatWithMilliseconds( 30 | symbol_id=packet[0], 31 | date_time=packet[1], 32 | price=packet[2], 33 | quantity=packet[3], 34 | side=packet[4], 35 | update_type=packet[5], 36 | num_orders=packet[6], 37 | final_update_in_batch=packet[7] 38 | ) 39 | 40 | @staticmethod 41 | def from_message_long(message_obj): 42 | return MarketDepthUpdateLevelFloatWithMilliseconds( 43 | symbol_id=message_obj.get('SymbolID'), 44 | date_time=message_obj.get('DateTime'), 45 | price=message_obj.get('Price'), 46 | quantity=message_obj.get('Quantity'), 47 | side=message_obj.get('Side'), 48 | update_type=message_obj.get('UpdateType'), 49 | num_orders=message_obj.get('NumOrders'), 50 | final_update_in_batch=message_obj.get('FinalUpdateInBatch') 51 | ) 52 | 53 | @staticmethod 54 | def from_message(message_obj): 55 | if 'F' in message_obj: 56 | return MarketDepthUpdateLevelFloatWithMilliseconds.from_message_short(message_obj) 57 | else: 58 | return MarketDepthUpdateLevelFloatWithMilliseconds.from_message_long(message_obj) 59 | 60 | @staticmethod 61 | def get_message_type_name(): 62 | return "MarketDepthUpdateLevelFloatWithMilliseconds" 63 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_update_level_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthUpdateLevelInt(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | side=None, 10 | price=None, 11 | quantity=None, 12 | update_type=None, 13 | date_time=None, 14 | num_orders=None): 15 | self.Type = MessageTypes.MARKET_DEPTH_UPDATE_LEVEL_INT 16 | self.SymbolID = symbol_id 17 | self.Side = side 18 | self.Price = price 19 | self.Quantity = quantity 20 | self.UpdateType = update_type 21 | self.DateTime = date_time 22 | self.NumOrders = num_orders 23 | 24 | @staticmethod 25 | def from_message_short(message_obj): 26 | packet = message_obj.get('F') 27 | return MarketDepthUpdateLevelInt( 28 | symbol_id=packet[0], 29 | side=packet[1], 30 | price=packet[2], 31 | quantity=packet[3], 32 | update_type=packet[4], 33 | date_time=packet[5], 34 | num_orders=packet[6] 35 | ) 36 | 37 | @staticmethod 38 | def from_message_long(message_obj): 39 | return MarketDepthUpdateLevelInt( 40 | symbol_id=message_obj.get('SymbolID'), 41 | side=message_obj.get('Side'), 42 | price=message_obj.get('Price'), 43 | quantity=message_obj.get('Quantity'), 44 | update_type=message_obj.get('UpdateType'), 45 | date_time=message_obj.get('DateTime'), 46 | num_orders=message_obj.get('NumOrders') 47 | ) 48 | 49 | @staticmethod 50 | def from_message(message_obj): 51 | if 'F' in message_obj: 52 | return MarketDepthUpdateLevelInt.from_message_short(message_obj) 53 | else: 54 | return MarketDepthUpdateLevelInt.from_message_long(message_obj) 55 | 56 | @staticmethod 57 | def get_message_type_name(): 58 | return "MarketDepthUpdateLevelInt" 59 | -------------------------------------------------------------------------------- /dtc/message_types/market_depth_update_level_no_timestamp.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class MarketDepthUpdateLevelNoTimestamp(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | price=None, 10 | quantity=None, 11 | num_orders=None, 12 | side=None, 13 | update_type=None, 14 | final_update_in_batch=None): 15 | self.Type = MessageTypes.MARKET_DEPTH_UPDATE_LEVEL_NO_TIMESTAMP 16 | self.SymbolID = symbol_id 17 | self.Price = price 18 | self.Quantity = quantity 19 | self.NumOrders = num_orders 20 | self.Side = side 21 | self.UpdateType = update_type 22 | self.FinalUpdateInBatch = final_update_in_batch 23 | 24 | @staticmethod 25 | def from_message_short(message_obj): 26 | packet = message_obj.get('F') 27 | return MarketDepthUpdateLevelNoTimestamp( 28 | symbol_id=packet[0], 29 | price=packet[1], 30 | quantity=packet[2], 31 | num_orders=packet[3], 32 | side=packet[4], 33 | update_type=packet[5], 34 | final_update_in_batch=packet[6] 35 | ) 36 | 37 | @staticmethod 38 | def from_message_long(message_obj): 39 | return MarketDepthUpdateLevelNoTimestamp( 40 | symbol_id=message_obj.get('SymbolID'), 41 | price=message_obj.get('Price'), 42 | quantity=message_obj.get('Quantity'), 43 | num_orders=message_obj.get('NumOrders'), 44 | side=message_obj.get('Side'), 45 | update_type=message_obj.get('UpdateType'), 46 | final_update_in_batch=message_obj.get('FinalUpdateInBatch') 47 | ) 48 | 49 | @staticmethod 50 | def from_message(message_obj): 51 | if 'F' in message_obj: 52 | return MarketDepthUpdateLevelNoTimestamp.from_message_short(message_obj) 53 | else: 54 | return MarketDepthUpdateLevelNoTimestamp.from_message_long(message_obj) 55 | 56 | @staticmethod 57 | def get_message_type_name(): 58 | return "MarketDepthUpdateLevelNoTimestamp" 59 | -------------------------------------------------------------------------------- /dtc/message_types/open_orders_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class OpenOrdersReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.OPEN_ORDERS_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return OpenOrdersReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return OpenOrdersReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return OpenOrdersReject.from_message_short(message_obj) 33 | else: 34 | return OpenOrdersReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "OpenOrdersReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/open_orders_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class OpenOrdersRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | request_all_orders=None, 10 | server_order_id=None, 11 | trade_account=None): 12 | self.Type = MessageTypes.OPEN_ORDERS_REQUEST 13 | self.RequestID = request_id 14 | self.RequestAllOrders = request_all_orders 15 | self.ServerOrderID = server_order_id 16 | self.TradeAccount = trade_account 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return OpenOrdersRequest( 22 | request_id=packet[0], 23 | request_all_orders=packet[1], 24 | server_order_id=packet[2], 25 | trade_account=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return OpenOrdersRequest( 31 | request_id=message_obj.get('RequestID'), 32 | request_all_orders=message_obj.get('RequestAllOrders'), 33 | server_order_id=message_obj.get('ServerOrderID'), 34 | trade_account=message_obj.get('TradeAccount') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return OpenOrdersRequest.from_message_short(message_obj) 41 | else: 42 | return OpenOrdersRequest.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "OpenOrdersRequest" 47 | -------------------------------------------------------------------------------- /dtc/message_types/position_update.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class PositionUpdate(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | total_number_messages=None, 10 | message_number=None, 11 | symbol=None, 12 | exchange=None, 13 | quantity=None, 14 | average_price=None, 15 | position_identifier=None, 16 | trade_account=None, 17 | no_positions=None, 18 | unsolicited=None, 19 | margin_requirement=None, 20 | entry_date_time=None): 21 | self.Type = MessageTypes.POSITION_UPDATE 22 | self.RequestID = request_id 23 | self.TotalNumberMessages = total_number_messages 24 | self.MessageNumber = message_number 25 | self.Symbol = symbol 26 | self.Exchange = exchange 27 | self.Quantity = quantity 28 | self.AveragePrice = average_price 29 | self.PositionIdentifier = position_identifier 30 | self.TradeAccount = trade_account 31 | self.NoPositions = no_positions 32 | self.Unsolicited = unsolicited 33 | self.MarginRequirement = margin_requirement 34 | self.EntryDateTime = entry_date_time 35 | 36 | @staticmethod 37 | def from_message_short(message_obj): 38 | packet = message_obj.get('F') 39 | return PositionUpdate( 40 | request_id=packet[0], 41 | total_number_messages=packet[1], 42 | message_number=packet[2], 43 | symbol=packet[3], 44 | exchange=packet[4], 45 | quantity=packet[5], 46 | average_price=packet[6], 47 | position_identifier=packet[7], 48 | trade_account=packet[8], 49 | no_positions=packet[9], 50 | unsolicited=packet[10], 51 | margin_requirement=packet[11], 52 | entry_date_time=packet[12] 53 | ) 54 | 55 | @staticmethod 56 | def from_message_long(message_obj): 57 | return PositionUpdate( 58 | request_id=message_obj.get('RequestID'), 59 | total_number_messages=message_obj.get('TotalNumberMessages'), 60 | message_number=message_obj.get('MessageNumber'), 61 | symbol=message_obj.get('Symbol'), 62 | exchange=message_obj.get('Exchange'), 63 | quantity=message_obj.get('Quantity'), 64 | average_price=message_obj.get('AveragePrice'), 65 | position_identifier=message_obj.get('PositionIdentifier'), 66 | trade_account=message_obj.get('TradeAccount'), 67 | no_positions=message_obj.get('NoPositions'), 68 | unsolicited=message_obj.get('Unsolicited'), 69 | margin_requirement=message_obj.get('MarginRequirement'), 70 | entry_date_time=message_obj.get('EntryDateTime') 71 | ) 72 | 73 | @staticmethod 74 | def from_message(message_obj): 75 | if 'F' in message_obj: 76 | return PositionUpdate.from_message_short(message_obj) 77 | else: 78 | return PositionUpdate.from_message_long(message_obj) 79 | 80 | @staticmethod 81 | def get_message_type_name(): 82 | return "PositionUpdate" 83 | -------------------------------------------------------------------------------- /dtc/message_types/security_definition_for_symbol_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SecurityDefinitionForSymbolRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | symbol=None, 10 | exchange=None): 11 | self.Type = MessageTypes.SECURITY_DEFINITION_FOR_SYMBOL_REQUEST 12 | self.RequestID = request_id 13 | self.Symbol = symbol 14 | self.Exchange = exchange 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return SecurityDefinitionForSymbolRequest( 20 | request_id=packet[0], 21 | symbol=packet[1], 22 | exchange=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return SecurityDefinitionForSymbolRequest( 28 | request_id=message_obj.get('RequestID'), 29 | symbol=message_obj.get('Symbol'), 30 | exchange=message_obj.get('Exchange') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return SecurityDefinitionForSymbolRequest.from_message_short(message_obj) 37 | else: 38 | return SecurityDefinitionForSymbolRequest.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "SecurityDefinitionForSymbolRequest" 43 | -------------------------------------------------------------------------------- /dtc/message_types/security_definition_reject.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SecurityDefinitionReject(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | reject_text=None): 10 | self.Type = MessageTypes.SECURITY_DEFINITION_REJECT 11 | self.RequestID = request_id 12 | self.RejectText = reject_text 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return SecurityDefinitionReject( 18 | request_id=packet[0], 19 | reject_text=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return SecurityDefinitionReject( 25 | request_id=message_obj.get('RequestID'), 26 | reject_text=message_obj.get('RejectText') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return SecurityDefinitionReject.from_message_short(message_obj) 33 | else: 34 | return SecurityDefinitionReject.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "SecurityDefinitionReject" 39 | -------------------------------------------------------------------------------- /dtc/message_types/submit_flatten_position_order.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SubmitFlattenPositionOrder(BaseMessageType): 7 | def __init__(self, 8 | symbol=None, 9 | exchange=None, 10 | trade_account=None, 11 | client_order_id=None, 12 | free_form_text=None, 13 | is_automated_order=None): 14 | self.Type = MessageTypes.SUBMIT_FLATTEN_POSITION_ORDER 15 | self.Symbol = symbol 16 | self.Exchange = exchange 17 | self.TradeAccount = trade_account 18 | self.ClientOrderID = client_order_id 19 | self.FreeFormText = free_form_text 20 | self.IsAutomatedOrder = is_automated_order 21 | 22 | @staticmethod 23 | def from_message_short(message_obj): 24 | packet = message_obj.get('F') 25 | return SubmitFlattenPositionOrder( 26 | symbol=packet[0], 27 | exchange=packet[1], 28 | trade_account=packet[2], 29 | client_order_id=packet[3], 30 | free_form_text=packet[4], 31 | is_automated_order=packet[5] 32 | ) 33 | 34 | @staticmethod 35 | def from_message_long(message_obj): 36 | return SubmitFlattenPositionOrder( 37 | symbol=message_obj.get('Symbol'), 38 | exchange=message_obj.get('Exchange'), 39 | trade_account=message_obj.get('TradeAccount'), 40 | client_order_id=message_obj.get('ClientOrderID'), 41 | free_form_text=message_obj.get('FreeFormText'), 42 | is_automated_order=message_obj.get('IsAutomatedOrder') 43 | ) 44 | 45 | @staticmethod 46 | def from_message(message_obj): 47 | if 'F' in message_obj: 48 | return SubmitFlattenPositionOrder.from_message_short(message_obj) 49 | else: 50 | return SubmitFlattenPositionOrder.from_message_long(message_obj) 51 | 52 | @staticmethod 53 | def get_message_type_name(): 54 | return "SubmitFlattenPositionOrder" 55 | -------------------------------------------------------------------------------- /dtc/message_types/submit_new_oco_order.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SubmitNewOCOOrder(BaseMessageType): 7 | def __init__(self, 8 | symbol=None, 9 | exchange=None, 10 | client_order_id_1=None, 11 | order_type_1=None, 12 | buy_sell_1=None, 13 | price1_1=None, 14 | price2_1=None, 15 | quantity_1=None, 16 | client_order_id_2=None, 17 | order_type_2=None, 18 | buy_sell_2=None, 19 | price1_2=None, 20 | price2_2=None, 21 | quantity_2=None, 22 | time_in_force=None, 23 | good_till_date_time=None, 24 | trade_account=None, 25 | is_automated_order=None, 26 | parent_trigger_client_order_id=None, 27 | free_form_text=None, 28 | open_or_close=None, 29 | partial_fill_handling=None, 30 | use_offsets=None, 31 | offset_from_parent1=None, 32 | offset_from_parent2=None): 33 | self.Type = MessageTypes.SUBMIT_NEW_OCO_ORDER 34 | self.Symbol = symbol 35 | self.Exchange = exchange 36 | self.ClientOrderID_1 = client_order_id_1 37 | self.OrderType_1 = order_type_1 38 | self.BuySell_1 = buy_sell_1 39 | self.Price1_1 = price1_1 40 | self.Price2_1 = price2_1 41 | self.Quantity_1 = quantity_1 42 | self.ClientOrderID_2 = client_order_id_2 43 | self.OrderType_2 = order_type_2 44 | self.BuySell_2 = buy_sell_2 45 | self.Price1_2 = price1_2 46 | self.Price2_2 = price2_2 47 | self.Quantity_2 = quantity_2 48 | self.TimeInForce = time_in_force 49 | self.GoodTillDateTime = good_till_date_time 50 | self.TradeAccount = trade_account 51 | self.IsAutomatedOrder = is_automated_order 52 | self.ParentTriggerClientOrderID = parent_trigger_client_order_id 53 | self.FreeFormText = free_form_text 54 | self.OpenOrClose = open_or_close 55 | self.PartialFillHandling = partial_fill_handling 56 | self.UseOffsets = use_offsets 57 | self.OffsetFromParent1 = offset_from_parent1 58 | self.OffsetFromParent2 = offset_from_parent2 59 | 60 | @staticmethod 61 | def from_message_short(message_obj): 62 | packet = message_obj.get('F') 63 | return SubmitNewOCOOrder( 64 | symbol=packet[0], 65 | exchange=packet[1], 66 | client_order_id_1=packet[2], 67 | order_type_1=packet[3], 68 | buy_sell_1=packet[4], 69 | price1_1=packet[5], 70 | price2_1=packet[6], 71 | quantity_1=packet[7], 72 | client_order_id_2=packet[8], 73 | order_type_2=packet[9], 74 | buy_sell_2=packet[10], 75 | price1_2=packet[11], 76 | price2_2=packet[12], 77 | quantity_2=packet[13], 78 | time_in_force=packet[14], 79 | good_till_date_time=packet[15], 80 | trade_account=packet[16], 81 | is_automated_order=packet[17], 82 | parent_trigger_client_order_id=packet[18], 83 | free_form_text=packet[19], 84 | open_or_close=packet[20], 85 | partial_fill_handling=packet[21], 86 | use_offsets=packet[22], 87 | offset_from_parent1=packet[23], 88 | offset_from_parent2=packet[24] 89 | ) 90 | 91 | @staticmethod 92 | def from_message_long(message_obj): 93 | return SubmitNewOCOOrder( 94 | symbol=message_obj.get('Symbol'), 95 | exchange=message_obj.get('Exchange'), 96 | client_order_id_1=message_obj.get('ClientOrderID_1'), 97 | order_type_1=message_obj.get('OrderType_1'), 98 | buy_sell_1=message_obj.get('BuySell_1'), 99 | price1_1=message_obj.get('Price1_1'), 100 | price2_1=message_obj.get('Price2_1'), 101 | quantity_1=message_obj.get('Quantity_1'), 102 | client_order_id_2=message_obj.get('ClientOrderID_2'), 103 | order_type_2=message_obj.get('OrderType_2'), 104 | buy_sell_2=message_obj.get('BuySell_2'), 105 | price1_2=message_obj.get('Price1_2'), 106 | price2_2=message_obj.get('Price2_2'), 107 | quantity_2=message_obj.get('Quantity_2'), 108 | time_in_force=message_obj.get('TimeInForce'), 109 | good_till_date_time=message_obj.get('GoodTillDateTime'), 110 | trade_account=message_obj.get('TradeAccount'), 111 | is_automated_order=message_obj.get('IsAutomatedOrder'), 112 | parent_trigger_client_order_id=message_obj.get('ParentTriggerClientOrderID'), 113 | free_form_text=message_obj.get('FreeFormText'), 114 | open_or_close=message_obj.get('OpenOrClose'), 115 | partial_fill_handling=message_obj.get('PartialFillHandling'), 116 | use_offsets=message_obj.get('UseOffsets'), 117 | offset_from_parent1=message_obj.get('OffsetFromParent1'), 118 | offset_from_parent2=message_obj.get('OffsetFromParent2') 119 | ) 120 | 121 | @staticmethod 122 | def from_message(message_obj): 123 | if 'F' in message_obj: 124 | return SubmitNewOCOOrder.from_message_short(message_obj) 125 | else: 126 | return SubmitNewOCOOrder.from_message_long(message_obj) 127 | 128 | @staticmethod 129 | def get_message_type_name(): 130 | return "SubmitNewOCOOrder" 131 | -------------------------------------------------------------------------------- /dtc/message_types/submit_new_oco_order_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SubmitNewOCOOrderInt(BaseMessageType): 7 | def __init__(self, 8 | symbol=None, 9 | exchange=None, 10 | client_order_id_1=None, 11 | order_type_1=None, 12 | buy_sell_1=None, 13 | price1_1=None, 14 | price2_1=None, 15 | quantity_1=None, 16 | client_order_id_2=None, 17 | order_type_2=None, 18 | buy_sell_2=None, 19 | price1_2=None, 20 | price2_2=None, 21 | quantity_2=None, 22 | time_in_force=None, 23 | good_till_date_time=None, 24 | trade_account=None, 25 | is_automated_order=None, 26 | parent_trigger_client_order_id=None, 27 | free_form_text=None, 28 | divisor=None, 29 | open_or_close=None, 30 | partial_fill_handling=None): 31 | self.Type = MessageTypes.SUBMIT_NEW_OCO_ORDER_INT 32 | self.Symbol = symbol 33 | self.Exchange = exchange 34 | self.ClientOrderID_1 = client_order_id_1 35 | self.OrderType_1 = order_type_1 36 | self.BuySell_1 = buy_sell_1 37 | self.Price1_1 = price1_1 38 | self.Price2_1 = price2_1 39 | self.Quantity_1 = quantity_1 40 | self.ClientOrderID_2 = client_order_id_2 41 | self.OrderType_2 = order_type_2 42 | self.BuySell_2 = buy_sell_2 43 | self.Price1_2 = price1_2 44 | self.Price2_2 = price2_2 45 | self.Quantity_2 = quantity_2 46 | self.TimeInForce = time_in_force 47 | self.GoodTillDateTime = good_till_date_time 48 | self.TradeAccount = trade_account 49 | self.IsAutomatedOrder = is_automated_order 50 | self.ParentTriggerClientOrderID = parent_trigger_client_order_id 51 | self.FreeFormText = free_form_text 52 | self.Divisor = divisor 53 | self.OpenOrClose = open_or_close 54 | self.PartialFillHandling = partial_fill_handling 55 | 56 | @staticmethod 57 | def from_message_short(message_obj): 58 | packet = message_obj.get('F') 59 | return SubmitNewOCOOrderInt( 60 | symbol=packet[0], 61 | exchange=packet[1], 62 | client_order_id_1=packet[2], 63 | order_type_1=packet[3], 64 | buy_sell_1=packet[4], 65 | price1_1=packet[5], 66 | price2_1=packet[6], 67 | quantity_1=packet[7], 68 | client_order_id_2=packet[8], 69 | order_type_2=packet[9], 70 | buy_sell_2=packet[10], 71 | price1_2=packet[11], 72 | price2_2=packet[12], 73 | quantity_2=packet[13], 74 | time_in_force=packet[14], 75 | good_till_date_time=packet[15], 76 | trade_account=packet[16], 77 | is_automated_order=packet[17], 78 | parent_trigger_client_order_id=packet[18], 79 | free_form_text=packet[19], 80 | divisor=packet[20], 81 | open_or_close=packet[21], 82 | partial_fill_handling=packet[22] 83 | ) 84 | 85 | @staticmethod 86 | def from_message_long(message_obj): 87 | return SubmitNewOCOOrderInt( 88 | symbol=message_obj.get('Symbol'), 89 | exchange=message_obj.get('Exchange'), 90 | client_order_id_1=message_obj.get('ClientOrderID_1'), 91 | order_type_1=message_obj.get('OrderType_1'), 92 | buy_sell_1=message_obj.get('BuySell_1'), 93 | price1_1=message_obj.get('Price1_1'), 94 | price2_1=message_obj.get('Price2_1'), 95 | quantity_1=message_obj.get('Quantity_1'), 96 | client_order_id_2=message_obj.get('ClientOrderID_2'), 97 | order_type_2=message_obj.get('OrderType_2'), 98 | buy_sell_2=message_obj.get('BuySell_2'), 99 | price1_2=message_obj.get('Price1_2'), 100 | price2_2=message_obj.get('Price2_2'), 101 | quantity_2=message_obj.get('Quantity_2'), 102 | time_in_force=message_obj.get('TimeInForce'), 103 | good_till_date_time=message_obj.get('GoodTillDateTime'), 104 | trade_account=message_obj.get('TradeAccount'), 105 | is_automated_order=message_obj.get('IsAutomatedOrder'), 106 | parent_trigger_client_order_id=message_obj.get('ParentTriggerClientOrderID'), 107 | free_form_text=message_obj.get('FreeFormText'), 108 | divisor=message_obj.get('Divisor'), 109 | open_or_close=message_obj.get('OpenOrClose'), 110 | partial_fill_handling=message_obj.get('PartialFillHandling') 111 | ) 112 | 113 | @staticmethod 114 | def from_message(message_obj): 115 | if 'F' in message_obj: 116 | return SubmitNewOCOOrderInt.from_message_short(message_obj) 117 | else: 118 | return SubmitNewOCOOrderInt.from_message_long(message_obj) 119 | 120 | @staticmethod 121 | def get_message_type_name(): 122 | return "SubmitNewOCOOrderInt" 123 | -------------------------------------------------------------------------------- /dtc/message_types/submit_new_single_order.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SubmitNewSingleOrder(BaseMessageType): 7 | def __init__(self, 8 | symbol=None, 9 | exchange=None, 10 | trade_account=None, 11 | client_order_id=None, 12 | order_type=None, 13 | buy_sell=None, 14 | price1=None, 15 | price2=None, 16 | quantity=None, 17 | time_in_force=None, 18 | good_till_date_time=None, 19 | is_automated_order=None, 20 | is_parent_order=None, 21 | free_form_text=None, 22 | open_or_close=None, 23 | max_show_quantity=None): 24 | self.Type = MessageTypes.SUBMIT_NEW_SINGLE_ORDER 25 | self.Symbol = symbol 26 | self.Exchange = exchange 27 | self.TradeAccount = trade_account 28 | self.ClientOrderID = client_order_id 29 | self.OrderType = order_type 30 | self.BuySell = buy_sell 31 | self.Price1 = price1 32 | self.Price2 = price2 33 | self.Quantity = quantity 34 | self.TimeInForce = time_in_force 35 | self.GoodTillDateTime = good_till_date_time 36 | self.IsAutomatedOrder = is_automated_order 37 | self.IsParentOrder = is_parent_order 38 | self.FreeFormText = free_form_text 39 | self.OpenOrClose = open_or_close 40 | self.MaxShowQuantity = max_show_quantity 41 | 42 | @staticmethod 43 | def from_message_short(message_obj): 44 | packet = message_obj.get('F') 45 | return SubmitNewSingleOrder( 46 | symbol=packet[0], 47 | exchange=packet[1], 48 | trade_account=packet[2], 49 | client_order_id=packet[3], 50 | order_type=packet[4], 51 | buy_sell=packet[5], 52 | price1=packet[6], 53 | price2=packet[7], 54 | quantity=packet[8], 55 | time_in_force=packet[9], 56 | good_till_date_time=packet[10], 57 | is_automated_order=packet[11], 58 | is_parent_order=packet[12], 59 | free_form_text=packet[13], 60 | open_or_close=packet[14], 61 | max_show_quantity=packet[15] 62 | ) 63 | 64 | @staticmethod 65 | def from_message_long(message_obj): 66 | return SubmitNewSingleOrder( 67 | symbol=message_obj.get('Symbol'), 68 | exchange=message_obj.get('Exchange'), 69 | trade_account=message_obj.get('TradeAccount'), 70 | client_order_id=message_obj.get('ClientOrderID'), 71 | order_type=message_obj.get('OrderType'), 72 | buy_sell=message_obj.get('BuySell'), 73 | price1=message_obj.get('Price1'), 74 | price2=message_obj.get('Price2'), 75 | quantity=message_obj.get('Quantity'), 76 | time_in_force=message_obj.get('TimeInForce'), 77 | good_till_date_time=message_obj.get('GoodTillDateTime'), 78 | is_automated_order=message_obj.get('IsAutomatedOrder'), 79 | is_parent_order=message_obj.get('IsParentOrder'), 80 | free_form_text=message_obj.get('FreeFormText'), 81 | open_or_close=message_obj.get('OpenOrClose'), 82 | max_show_quantity=message_obj.get('MaxShowQuantity') 83 | ) 84 | 85 | @staticmethod 86 | def from_message(message_obj): 87 | if 'F' in message_obj: 88 | return SubmitNewSingleOrder.from_message_short(message_obj) 89 | else: 90 | return SubmitNewSingleOrder.from_message_long(message_obj) 91 | 92 | @staticmethod 93 | def get_message_type_name(): 94 | return "SubmitNewSingleOrder" 95 | -------------------------------------------------------------------------------- /dtc/message_types/submit_new_single_order_int.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SubmitNewSingleOrderInt(BaseMessageType): 7 | def __init__(self, 8 | symbol=None, 9 | exchange=None, 10 | trade_account=None, 11 | client_order_id=None, 12 | order_type=None, 13 | buy_sell=None, 14 | price1=None, 15 | price2=None, 16 | divisor=None, 17 | quantity=None, 18 | time_in_force=None, 19 | good_till_date_time=None, 20 | is_automated_order=None, 21 | is_parent_order=None, 22 | free_form_text=None, 23 | open_or_close=None): 24 | self.Type = MessageTypes.SUBMIT_NEW_SINGLE_ORDER_INT 25 | self.Symbol = symbol 26 | self.Exchange = exchange 27 | self.TradeAccount = trade_account 28 | self.ClientOrderID = client_order_id 29 | self.OrderType = order_type 30 | self.BuySell = buy_sell 31 | self.Price1 = price1 32 | self.Price2 = price2 33 | self.Divisor = divisor 34 | self.Quantity = quantity 35 | self.TimeInForce = time_in_force 36 | self.GoodTillDateTime = good_till_date_time 37 | self.IsAutomatedOrder = is_automated_order 38 | self.IsParentOrder = is_parent_order 39 | self.FreeFormText = free_form_text 40 | self.OpenOrClose = open_or_close 41 | 42 | @staticmethod 43 | def from_message_short(message_obj): 44 | packet = message_obj.get('F') 45 | return SubmitNewSingleOrderInt( 46 | symbol=packet[0], 47 | exchange=packet[1], 48 | trade_account=packet[2], 49 | client_order_id=packet[3], 50 | order_type=packet[4], 51 | buy_sell=packet[5], 52 | price1=packet[6], 53 | price2=packet[7], 54 | divisor=packet[8], 55 | quantity=packet[9], 56 | time_in_force=packet[10], 57 | good_till_date_time=packet[11], 58 | is_automated_order=packet[12], 59 | is_parent_order=packet[13], 60 | free_form_text=packet[14], 61 | open_or_close=packet[15] 62 | ) 63 | 64 | @staticmethod 65 | def from_message_long(message_obj): 66 | return SubmitNewSingleOrderInt( 67 | symbol=message_obj.get('Symbol'), 68 | exchange=message_obj.get('Exchange'), 69 | trade_account=message_obj.get('TradeAccount'), 70 | client_order_id=message_obj.get('ClientOrderID'), 71 | order_type=message_obj.get('OrderType'), 72 | buy_sell=message_obj.get('BuySell'), 73 | price1=message_obj.get('Price1'), 74 | price2=message_obj.get('Price2'), 75 | divisor=message_obj.get('Divisor'), 76 | quantity=message_obj.get('Quantity'), 77 | time_in_force=message_obj.get('TimeInForce'), 78 | good_till_date_time=message_obj.get('GoodTillDateTime'), 79 | is_automated_order=message_obj.get('IsAutomatedOrder'), 80 | is_parent_order=message_obj.get('IsParentOrder'), 81 | free_form_text=message_obj.get('FreeFormText'), 82 | open_or_close=message_obj.get('OpenOrClose') 83 | ) 84 | 85 | @staticmethod 86 | def from_message(message_obj): 87 | if 'F' in message_obj: 88 | return SubmitNewSingleOrderInt.from_message_short(message_obj) 89 | else: 90 | return SubmitNewSingleOrderInt.from_message_long(message_obj) 91 | 92 | @staticmethod 93 | def get_message_type_name(): 94 | return "SubmitNewSingleOrderInt" 95 | -------------------------------------------------------------------------------- /dtc/message_types/symbol_search_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SymbolSearchRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | search_text=None, 10 | exchange=None, 11 | security_type=None, 12 | search_type=None): 13 | self.Type = MessageTypes.SYMBOL_SEARCH_REQUEST 14 | self.RequestID = request_id 15 | self.SearchText = search_text 16 | self.Exchange = exchange 17 | self.SecurityType = security_type 18 | self.SearchType = search_type 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return SymbolSearchRequest( 24 | request_id=packet[0], 25 | search_text=packet[1], 26 | exchange=packet[2], 27 | security_type=packet[3], 28 | search_type=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return SymbolSearchRequest( 34 | request_id=message_obj.get('RequestID'), 35 | search_text=message_obj.get('SearchText'), 36 | exchange=message_obj.get('Exchange'), 37 | security_type=message_obj.get('SecurityType'), 38 | search_type=message_obj.get('SearchType') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return SymbolSearchRequest.from_message_short(message_obj) 45 | else: 46 | return SymbolSearchRequest.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "SymbolSearchRequest" 51 | -------------------------------------------------------------------------------- /dtc/message_types/symbols_for_exchange_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SymbolsForExchangeRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | exchange=None, 10 | security_type=None, 11 | request_action=None, 12 | symbol=None): 13 | self.Type = MessageTypes.SYMBOLS_FOR_EXCHANGE_REQUEST 14 | self.RequestID = request_id 15 | self.Exchange = exchange 16 | self.SecurityType = security_type 17 | self.RequestAction = request_action 18 | self.Symbol = symbol 19 | 20 | @staticmethod 21 | def from_message_short(message_obj): 22 | packet = message_obj.get('F') 23 | return SymbolsForExchangeRequest( 24 | request_id=packet[0], 25 | exchange=packet[1], 26 | security_type=packet[2], 27 | request_action=packet[3], 28 | symbol=packet[4] 29 | ) 30 | 31 | @staticmethod 32 | def from_message_long(message_obj): 33 | return SymbolsForExchangeRequest( 34 | request_id=message_obj.get('RequestID'), 35 | exchange=message_obj.get('Exchange'), 36 | security_type=message_obj.get('SecurityType'), 37 | request_action=message_obj.get('RequestAction'), 38 | symbol=message_obj.get('Symbol') 39 | ) 40 | 41 | @staticmethod 42 | def from_message(message_obj): 43 | if 'F' in message_obj: 44 | return SymbolsForExchangeRequest.from_message_short(message_obj) 45 | else: 46 | return SymbolsForExchangeRequest.from_message_long(message_obj) 47 | 48 | @staticmethod 49 | def get_message_type_name(): 50 | return "SymbolsForExchangeRequest" 51 | -------------------------------------------------------------------------------- /dtc/message_types/symbols_for_underlying_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class SymbolsForUnderlyingRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | underlying_symbol=None, 10 | exchange=None, 11 | security_type=None): 12 | self.Type = MessageTypes.SYMBOLS_FOR_UNDERLYING_REQUEST 13 | self.RequestID = request_id 14 | self.UnderlyingSymbol = underlying_symbol 15 | self.Exchange = exchange 16 | self.SecurityType = security_type 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return SymbolsForUnderlyingRequest( 22 | request_id=packet[0], 23 | underlying_symbol=packet[1], 24 | exchange=packet[2], 25 | security_type=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return SymbolsForUnderlyingRequest( 31 | request_id=message_obj.get('RequestID'), 32 | underlying_symbol=message_obj.get('UnderlyingSymbol'), 33 | exchange=message_obj.get('Exchange'), 34 | security_type=message_obj.get('SecurityType') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return SymbolsForUnderlyingRequest.from_message_short(message_obj) 41 | else: 42 | return SymbolsForUnderlyingRequest.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "SymbolsForUnderlyingRequest" 47 | -------------------------------------------------------------------------------- /dtc/message_types/trade_account_response.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class TradeAccountResponse(BaseMessageType): 7 | def __init__(self, 8 | total_number_messages=None, 9 | message_number=None, 10 | trade_account=None, 11 | request_id=None): 12 | self.Type = MessageTypes.TRADE_ACCOUNT_RESPONSE 13 | self.TotalNumberMessages = total_number_messages 14 | self.MessageNumber = message_number 15 | self.TradeAccount = trade_account 16 | self.RequestID = request_id 17 | 18 | @staticmethod 19 | def from_message_short(message_obj): 20 | packet = message_obj.get('F') 21 | return TradeAccountResponse( 22 | total_number_messages=packet[0], 23 | message_number=packet[1], 24 | trade_account=packet[2], 25 | request_id=packet[3] 26 | ) 27 | 28 | @staticmethod 29 | def from_message_long(message_obj): 30 | return TradeAccountResponse( 31 | total_number_messages=message_obj.get('TotalNumberMessages'), 32 | message_number=message_obj.get('MessageNumber'), 33 | trade_account=message_obj.get('TradeAccount'), 34 | request_id=message_obj.get('RequestID') 35 | ) 36 | 37 | @staticmethod 38 | def from_message(message_obj): 39 | if 'F' in message_obj: 40 | return TradeAccountResponse.from_message_short(message_obj) 41 | else: 42 | return TradeAccountResponse.from_message_long(message_obj) 43 | 44 | @staticmethod 45 | def get_message_type_name(): 46 | return "TradeAccountResponse" 47 | -------------------------------------------------------------------------------- /dtc/message_types/trade_accounts_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class TradeAccountsRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None): 9 | self.Type = MessageTypes.TRADE_ACCOUNTS_REQUEST 10 | self.RequestID = request_id 11 | 12 | @staticmethod 13 | def from_message_short(message_obj): 14 | packet = message_obj.get('F') 15 | return TradeAccountsRequest( 16 | request_id=packet[0] 17 | ) 18 | 19 | @staticmethod 20 | def from_message_long(message_obj): 21 | return TradeAccountsRequest( 22 | request_id=message_obj.get('RequestID') 23 | ) 24 | 25 | @staticmethod 26 | def from_message(message_obj): 27 | if 'F' in message_obj: 28 | return TradeAccountsRequest.from_message_short(message_obj) 29 | else: 30 | return TradeAccountsRequest.from_message_long(message_obj) 31 | 32 | @staticmethod 33 | def get_message_type_name(): 34 | return "TradeAccountsRequest" 35 | -------------------------------------------------------------------------------- /dtc/message_types/trading_symbol_status.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class TradingSymbolStatus(BaseMessageType): 7 | def __init__(self, 8 | symbol_id=None, 9 | status=None): 10 | self.Type = MessageTypes.TRADING_SYMBOL_STATUS 11 | self.SymbolID = symbol_id 12 | self.Status = status 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return TradingSymbolStatus( 18 | symbol_id=packet[0], 19 | status=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return TradingSymbolStatus( 25 | symbol_id=message_obj.get('SymbolID'), 26 | status=message_obj.get('Status') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return TradingSymbolStatus.from_message_short(message_obj) 33 | else: 34 | return TradingSymbolStatus.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "TradingSymbolStatus" 39 | -------------------------------------------------------------------------------- /dtc/message_types/underlying_symbols_for_exchange_request.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class UnderlyingSymbolsForExchangeRequest(BaseMessageType): 7 | def __init__(self, 8 | request_id=None, 9 | exchange=None, 10 | security_type=None): 11 | self.Type = MessageTypes.UNDERLYING_SYMBOLS_FOR_EXCHANGE_REQUEST 12 | self.RequestID = request_id 13 | self.Exchange = exchange 14 | self.SecurityType = security_type 15 | 16 | @staticmethod 17 | def from_message_short(message_obj): 18 | packet = message_obj.get('F') 19 | return UnderlyingSymbolsForExchangeRequest( 20 | request_id=packet[0], 21 | exchange=packet[1], 22 | security_type=packet[2] 23 | ) 24 | 25 | @staticmethod 26 | def from_message_long(message_obj): 27 | return UnderlyingSymbolsForExchangeRequest( 28 | request_id=message_obj.get('RequestID'), 29 | exchange=message_obj.get('Exchange'), 30 | security_type=message_obj.get('SecurityType') 31 | ) 32 | 33 | @staticmethod 34 | def from_message(message_obj): 35 | if 'F' in message_obj: 36 | return UnderlyingSymbolsForExchangeRequest.from_message_short(message_obj) 37 | else: 38 | return UnderlyingSymbolsForExchangeRequest.from_message_long(message_obj) 39 | 40 | @staticmethod 41 | def get_message_type_name(): 42 | return "UnderlyingSymbolsForExchangeRequest" 43 | -------------------------------------------------------------------------------- /dtc/message_types/user_message.py: -------------------------------------------------------------------------------- 1 | 2 | from dtc.enums.message_types import MessageTypes 3 | from lib.base_message_type import BaseMessageType 4 | 5 | 6 | class UserMessage(BaseMessageType): 7 | def __init__(self, 8 | user_message=None, 9 | is_popup_message=None): 10 | self.Type = MessageTypes.USER_MESSAGE 11 | self.UserMessage = user_message 12 | self.IsPopupMessage = is_popup_message 13 | 14 | @staticmethod 15 | def from_message_short(message_obj): 16 | packet = message_obj.get('F') 17 | return UserMessage( 18 | user_message=packet[0], 19 | is_popup_message=packet[1] 20 | ) 21 | 22 | @staticmethod 23 | def from_message_long(message_obj): 24 | return UserMessage( 25 | user_message=message_obj.get('UserMessage'), 26 | is_popup_message=message_obj.get('IsPopupMessage') 27 | ) 28 | 29 | @staticmethod 30 | def from_message(message_obj): 31 | if 'F' in message_obj: 32 | return UserMessage.from_message_short(message_obj) 33 | else: 34 | return UserMessage.from_message_long(message_obj) 35 | 36 | @staticmethod 37 | def get_message_type_name(): 38 | return "UserMessage" 39 | -------------------------------------------------------------------------------- /dtc/util/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/dtc/util/__init__.py -------------------------------------------------------------------------------- /dtc_client/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/dtc_client/__init__.py -------------------------------------------------------------------------------- /dtc_client/data_message_types.py: -------------------------------------------------------------------------------- 1 | from dtc.enums.message_types import MessageTypes 2 | 3 | MARKET_DATA_MESSAGE_TYPES = [ 4 | MessageTypes.MARKET_DATA_UPDATE_TRADE, 5 | MessageTypes.MARKET_DATA_UPDATE_TRADE_COMPACT, 6 | MessageTypes.MARKET_DATA_UPDATE_TRADE_INT, 7 | MessageTypes.MARKET_DATA_UPDATE_LAST_TRADE_SNAPSHOT, 8 | MessageTypes.MARKET_DATA_UPDATE_TRADE_WITH_UNBUNDLED_INDICATOR, 9 | MessageTypes.MARKET_DATA_UPDATE_TRADE_NO_TIMESTAMP, 10 | MessageTypes.MARKET_DATA_UPDATE_BID_ASK, 11 | MessageTypes.MARKET_DATA_UPDATE_BID_ASK_COMPACT, 12 | MessageTypes.MARKET_DATA_UPDATE_BID_ASK_INT, 13 | MessageTypes.MARKET_DATA_UPDATE_BID_ASK_NO_TIMESTAMP, 14 | MessageTypes.MARKET_DATA_UPDATE_BID_ASK_FLOAT_WITH_MILLISECONDS, 15 | MessageTypes.MARKET_DATA_UPDATE_SESSION_OPEN, 16 | MessageTypes.MARKET_DATA_UPDATE_SESSION_OPEN_INT, 17 | MessageTypes.MARKET_DATA_UPDATE_SESSION_HIGH, 18 | MessageTypes.MARKET_DATA_UPDATE_SESSION_HIGH_INT, 19 | MessageTypes.MARKET_DATA_UPDATE_SESSION_LOW, 20 | MessageTypes.MARKET_DATA_UPDATE_SESSION_LOW_INT, 21 | MessageTypes.MARKET_DATA_UPDATE_SESSION_VOLUME, 22 | MessageTypes.MARKET_DATA_UPDATE_OPEN_INTEREST, 23 | MessageTypes.MARKET_DATA_UPDATE_SESSION_SETTLEMENT, 24 | MessageTypes.MARKET_DATA_UPDATE_SESSION_SETTLEMENT_INT, 25 | MessageTypes.MARKET_DATA_UPDATE_SESSION_NUM_TRADES, 26 | MessageTypes.MARKET_DATA_UPDATE_TRADING_SESSION_DATE 27 | ] 28 | 29 | MARKET_DEPTH_MESSAGE_TYPES = [ 30 | MessageTypes.MARKET_DEPTH_UPDATE_LEVEL, 31 | MessageTypes.MARKET_DEPTH_UPDATE_LEVEL_FLOAT_WITH_MILLISECONDS, 32 | MessageTypes.MARKET_DEPTH_UPDATE_LEVEL_NO_TIMESTAMP, 33 | MessageTypes.MARKET_DEPTH_UPDATE_LEVEL_INT 34 | ] 35 | 36 | HISTORICAL_DATA_MESSAGE_TYPES = [ 37 | MessageTypes.HISTORICAL_PRICE_DATA_RESPONSE_HEADER, 38 | MessageTypes.HISTORICAL_PRICE_DATA_RECORD_RESPONSE, 39 | MessageTypes.HISTORICAL_PRICE_DATA_TICK_RECORD_RESPONSE, 40 | MessageTypes.HISTORICAL_PRICE_DATA_RECORD_RESPONSE_INT, 41 | MessageTypes.HISTORICAL_PRICE_DATA_TICK_RECORD_RESPONSE_INT, 42 | MessageTypes.HISTORICAL_PRICE_DATA_RESPONSE_TRAILER 43 | ] 44 | -------------------------------------------------------------------------------- /dtc_client/enums.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | class SubscriptionDataType: 4 | MARKET_DATA = "MARKET_DATA" 5 | MARKET_DEPTH = "MARKET_DEPTH" 6 | -------------------------------------------------------------------------------- /example_client.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import traceback 3 | 4 | from dtc_client.dtc_client import DTCClient 5 | from dtc.message_types.market_data_request import MarketDataRequest 6 | from dtc.enums.request_action_enum import RequestActionEnum 7 | from dtc.message_types.market_data_snapshot import MarketDataSnapshot 8 | from lib.symbol_util import get_symbol_id 9 | from lib.util import Util, CONSOLE_LOGGING 10 | 11 | _NAME = 'name' 12 | _ID = 'ID' 13 | 14 | 15 | if __name__ == '__main__': 16 | # Symbols to monitor 17 | SYMBOL_LIST = [ 18 | {_NAME: "ESM20_FUT_CME"}, 19 | {_NAME: "CLM20_FUT_NYMEX"} 20 | ] 21 | # Generate symbol IDs 22 | for ix, symbol in enumerate(SYMBOL_LIST): 23 | SYMBOL_LIST[ix][_ID] = get_symbol_id(symbol[_NAME]) 24 | 25 | class ExampleDTCClient(DTCClient): 26 | def __init__(self): 27 | super().__init__(on_message_handler=self.on_message_thread, post_login_thread=self.post_login_thread) 28 | 29 | def post_login_thread(self): 30 | for ix, symbol in enumerate(SYMBOL_LIST): 31 | self.send( 32 | MarketDataRequest( 33 | request_action=RequestActionEnum.SUBSCRIBE, 34 | symbol_id=SYMBOL_LIST[ix][_ID], 35 | symbol=symbol[_NAME])) 36 | 37 | def on_message_thread(self, message): 38 | if isinstance(message, MarketDataSnapshot): 39 | marketDataSnapshot = MarketDataSnapshot() 40 | # do something with market data 41 | 42 | 43 | try: 44 | logger = Util.setup_logging("DTC_Client", console=CONSOLE_LOGGING) 45 | dtc_client = ExampleDTCClient() 46 | dtc_client.start() 47 | except BaseException as e: 48 | logging.error(e.__str__()) 49 | logging.debug(traceback.format_exc()) 50 | -------------------------------------------------------------------------------- /lib/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/lib/__init__.py -------------------------------------------------------------------------------- /lib/base_message_type.py: -------------------------------------------------------------------------------- 1 | import json 2 | 3 | USERNAME = 'Username' 4 | PASSWORD = 'Password' 5 | TRADE_ACCOUNT = 'TradeAccount' 6 | STARS = "********" 7 | 8 | 9 | class BaseMessageType: 10 | def to_JSON(self, pretty=False, logging=True): 11 | def remove_nulls(d): 12 | return {k: v for k, v in d.items() if v is not None} 13 | 14 | indent = 4 if pretty else None 15 | res = json.loads(json.dumps(self, default=lambda o: o.__dict__), object_hook=remove_nulls) 16 | # mask some sensitive values 17 | if logging: 18 | #if USERNAME in res: 19 | # res[USERNAME] = STARS 20 | if PASSWORD in res: 21 | res[PASSWORD] = STARS 22 | #if TRADE_ACCOUNT in res: 23 | # res[TRADE_ACCOUNT] = STARS 24 | return json.dumps(res, sort_keys=True, indent=indent) 25 | -------------------------------------------------------------------------------- /lib/constants.py: -------------------------------------------------------------------------------- 1 | import logging 2 | import os 3 | import sys 4 | 5 | PROTOCOL_VERSION = 8 6 | 7 | DEFAULT_LOG_LEVEL = 'INFO' 8 | 9 | LOG_DIR = '/var/log/dtc' 10 | 11 | LOG_LEVEL = 'LOG_LEVEL' 12 | PROGRAM_NAME = os.path.basename(sys.argv[0]).replace(".py", "") 13 | LOG_FILE = LOG_DIR + '/' + PROGRAM_NAME + ".log" 14 | LOG_FORMAT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s' 15 | 16 | FILE_NAME_DATE_PREFIX = "%Y-%m-%d_%H_%M_%S" 17 | 18 | CONSOLE_LOGGING = True 19 | -------------------------------------------------------------------------------- /lib/error.py: -------------------------------------------------------------------------------- 1 | 2 | 3 | class ClientError(Exception): 4 | """Base class for exceptions in this module.""" 5 | 6 | def __init__(self, message): 7 | super(ClientError, self).__init__(message) 8 | 9 | 10 | class InvalidArgumentsError(ClientError): 11 | def __init__(self, message="Invalid Arguments Error"): 12 | super(ClientError, self).__init__(message) 13 | 14 | 15 | class LogonError(ClientError): 16 | def __init__(self, message="Logon Error"): 17 | super(ClientError, self).__init__(message) 18 | 19 | 20 | class MethodNotAllowedError(ClientError): 21 | def __init__(self, message="Method Not Allowed Error"): 22 | super(ClientError, self).__init__(message) 23 | 24 | 25 | class RequestTimeoutError(ClientError): 26 | def __init__(self, message="Timed out waiting for a response."): 27 | super(ClientError, self).__init__(message) 28 | 29 | 30 | -------------------------------------------------------------------------------- /lib/symbol_util.py: -------------------------------------------------------------------------------- 1 | import hashlib 2 | 3 | 4 | def get_symbol_id(symbol): 5 | return int(hashlib.sha1(symbol.encode('utf-8')).hexdigest(), 16) % 4294967295 -------------------------------------------------------------------------------- /lib/util.py: -------------------------------------------------------------------------------- 1 | #!/usr/bin/python 2 | 3 | import argparse 4 | import json 5 | import subprocess 6 | from datetime import datetime 7 | 8 | from lib.constants import * 9 | 10 | 11 | class Util: 12 | @staticmethod 13 | def set_promiscuous_mode(interface): 14 | import os 15 | ret = os.system("ifconfig %s promisc" % interface) 16 | 17 | @staticmethod 18 | def get_timestamp_string(datetime_now=None): 19 | if not datetime_now: 20 | datetime_now = datetime.now() 21 | return datetime_now.strftime(FILE_NAME_DATE_PREFIX) 22 | 23 | @staticmethod 24 | def setup_logging(logger_name, console=True, log_to_file=False): 25 | root_logger = logging.getLogger() 26 | root_logger.name = logger_name 27 | log_formatter = logging.Formatter(LOG_FORMAT) 28 | 29 | # log to file 30 | if log_to_file: 31 | log_dir = os.path.dirname(LOG_FILE) 32 | if not os.path.exists(log_dir): 33 | os.makedirs(log_dir) 34 | file_handler = logging.FileHandler(LOG_FILE) 35 | file_handler.setFormatter(log_formatter) 36 | root_logger.addHandler(file_handler) 37 | 38 | if console: 39 | stream_handler = logging.StreamHandler() 40 | stream_handler.setFormatter(log_formatter) 41 | root_logger.addHandler(stream_handler) 42 | 43 | log_level = os.getenv(LOG_LEVEL) if os.getenv(LOG_LEVEL) else DEFAULT_LOG_LEVEL 44 | root_logger.setLevel(logging.getLevelName(log_level)) 45 | return root_logger 46 | 47 | @staticmethod 48 | def call(argv): 49 | proc = subprocess.Popen(argv, stdout=subprocess.PIPE, stderr=subprocess.PIPE) 50 | res = proc.wait() 51 | logging.info("returned status=%s stdout=\"%s\" stderr=\"%s\"" 52 | % (res, proc.stdout.read().rstrip(), proc.stderr.read().rstrip())) 53 | return res, proc 54 | 55 | @staticmethod 56 | def call_ls(): 57 | res, proc = Util.call(['ls']) 58 | 59 | @staticmethod 60 | def today_serial_date_part(): 61 | return datetime.utcnow().strftime('%Y%m%d') 62 | 63 | @staticmethod 64 | def json_dumps(obj): 65 | return json.dumps(obj, indent=4) 66 | 67 | 68 | class ArgParser(argparse.ArgumentParser): 69 | def error(self, message): 70 | logging.error(message) 71 | self.print_help() 72 | sys.exit(2) 73 | 74 | def _print_message(self, message, file=None): 75 | logging.error(message) 76 | 77 | -------------------------------------------------------------------------------- /rest/__init__.py: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/jason0598647/python-ws-dtc-client/fd3952cdaf7ab8c9d5a26ccf53b5e9acb3a9ea0f/rest/__init__.py -------------------------------------------------------------------------------- /rest/api.py: -------------------------------------------------------------------------------- 1 | 2 | class API: 3 | # BASE_URL 4 | API_PREFIX = '/api/v1' 5 | 6 | # REST Endpoints 7 | ACCOUNT_BALANCE = '/accountbalance' 8 | CURRENT_POSITIONS = '/currentpositions' 9 | EXCHANGE_LIST = '/exchangelist' 10 | HISTORICAL_ACCOUNT_BALANCES = '/historicalaccountbalances' 11 | HISTORICAL_ORDER_FILLS = '/historicalorderfills' 12 | SECURITY_DEFINITION = '/securitydefinition' 13 | TRADE_ACCOUNTS = '/tradeaccounts' 14 | HISTORICAL_PRICE_DATA = '/historicalpricedata' 15 | 16 | # WS Endpoints 17 | MARKET_DATA = '/marketdata' 18 | MARKET_DEPTH = '/marketdepth' 19 | -------------------------------------------------------------------------------- /rest/method.py: -------------------------------------------------------------------------------- 1 | 2 | class Method: 3 | GET = 'GET' 4 | POST = 'POST' 5 | PUT = 'PUT' 6 | DELETE = 'DELETE' 7 | --------------------------------------------------------------------------------