httptrading 1.0.2__py3-none-any.whl → 1.0.3__py3-none-any.whl

httptrading/__init__.py

@@ -4,3 +4,4 @@ from httptrading.broker.longbridge import *
 from httptrading.broker.tiger import *
 from httptrading.broker.interactive_brokers import *
 from httptrading.http_server import *
+from httptrading.model import HtGlobalConfig

httptrading/broker/base.py

@@ -1,8 +1,11 @@
+import os
+import json
 import asyncio
 import importlib
 from abc import ABC
 from typing import Type, Callable, Any
 from httptrading.model import *
+from httptrading.tool.locate import *
 
 
 class BaseBroker(ABC):
@@ -22,7 +25,10 @@ class BaseBroker(ABC):
         return BrokerRegister.get_meta(type(self)).display
 
     def detect_package(self):
-        pkg_info = BrokerRegister.get_meta(type(self)).detect_package
+        meta = BrokerRegister.get_meta(type(self))
+        if not meta:
+            return
+        pkg_info = meta.detect_package
         if pkg_info is None:
             return
         try:
@@ -36,6 +42,23 @@ class BaseBroker(ABC):
     async def shutdown(self):
         pass
 
+    def dump_order(self, order: Order):
+        if not isinstance(order, Order):
+            return
+        folder = HtGlobalConfig.STREAM_DUMP_FOLDER
+        if not folder:
+            return
+        if not os.path.isdir(folder):
+            return
+        json_str = json.dumps(
+            order,
+            indent=2,
+            default=HtGlobalConfig.JSON_DEFAULT.json_default,
+        )
+        filename = f'{self.instance_id}-{order.order_id}.json'
+        full_path = os.path.join(folder, filename)
+        LocateTools.write_file(full_path, json_str)
+
     async def call_sync(self, f: Callable[[], Any]):
         try:
             r = await asyncio.get_running_loop().run_in_executor(None, f)

httptrading/broker/futu_sec.py

@@ -30,6 +30,7 @@ class Futu(SecuritiesBroker):
 
     def _on_init(self):
         from futu import SysConfig, OpenQuoteContext, OpenSecTradeContext, SecurityFirm, TrdMarket, TrdEnv
+
         config_dict = self.broker_args
         self._trd_env: str = config_dict.get('trade_env', TrdEnv.REAL) or TrdEnv.REAL
         pk_path = config_dict.get('pk_path', '')
@@ -49,6 +50,7 @@ class Futu(SecuritiesBroker):
             )
             trade_ctx.set_sync_query_connect_timeout(6.0)
             self._trade_client = trade_ctx
+            self._when_create_client()
         if self._quote_client is None:
             SysConfig.set_all_thread_daemon(True)
             host = config_dict.get('host', '127.0.0.1')
@@ -57,6 +59,50 @@ class Futu(SecuritiesBroker):
             quote_ctx.set_sync_query_connect_timeout(6.0)
             self._quote_client = quote_ctx
 
+    def _when_create_client(self):
+        from futu import TradeOrderHandlerBase, RET_OK, OpenSecTradeContext
+
+        client: OpenSecTradeContext = self._trade_client
+
+        def _on_recv_rsp(content):
+            for _futu_order in self._df_to_list(content):
+                try:
+                    _order = self._build_order(_futu_order)
+                    self.dump_order(_order)
+                except Exception as _ex:
+                    print(f'[{self.__class__.__name__}]_on_recv_rsp: {_ex}\norder: {_futu_order}')
+
+        class TradeOrderHandler(TradeOrderHandlerBase):
+            def on_recv_rsp(self, rsp_pb):
+                ret, content = super().on_recv_rsp(rsp_pb)
+                if ret == RET_OK:
+                    _on_recv_rsp(content)
+                return ret, content
+
+        client.set_handler(TradeOrderHandler())
+
+    async def start(self):
+        from futu import RET_OK, OpenSecTradeContext
+
+        client: OpenSecTradeContext = self._trade_client
+        if HtGlobalConfig.DUMP_ACTIVE_ORDERS:
+            try:
+                ret, data = client.order_list_query(
+                    refresh_cache=True,
+                    trd_env=self._trd_env,
+                )
+            except Exception as e:
+                print(f'[{self.__class__.__name__}]DUMP_ACTIVE_ORDERS: {e}')
+            else:
+                if ret == RET_OK:
+                    futu_orders = self._df_to_list(data)
+                    for futu_order in futu_orders:
+                        try:
+                            order = self._build_order(futu_order)
+                            await self.call_sync(lambda : self.dump_order(order))
+                        except Exception as ex:
+                            print(f'[{self.__class__.__name__}]DUMP_ACTIVE_ORDERS: {ex}\norder: {futu_order}')
+
     @classmethod
     def code_to_contract(cls, code) -> Contract | None:
         region = ''
@@ -98,7 +144,7 @@ class Futu(SecuritiesBroker):
         return code
 
     @classmethod
-    def df_to_dict(cls, df) -> dict:
+    def _df_to_list(cls, df) -> list[dict]:
         return df.to_dict(orient='records')
 
     def _positions(self):
@@ -111,7 +157,7 @@ class Futu(SecuritiesBroker):
             )
         if resp != RET_OK:
             raise Exception(f'返回失败: {resp}')
-        positions = self.df_to_dict(data)
+        positions = self._df_to_list(data)
         for d in positions:
             code = d.get('code')
             currency = d.get('currency')
@@ -153,7 +199,7 @@ class Futu(SecuritiesBroker):
             )
         if resp != RET_OK:
             raise Exception(f'可用资金信息获取失败: {data}')
-        assets = self.df_to_dict(data)
+        assets = self._df_to_list(data)
         if len(assets) == 1:
             cash = Cash(
                 currency='USD',
@@ -219,7 +265,7 @@ class Futu(SecuritiesBroker):
             ret, data = self._quote_client.get_market_snapshot([code, ])
         if ret != RET_OK:
             raise ValueError(f'快照接口调用失败: {data}')
-        table = self.df_to_dict(data)
+        table = self._df_to_list(data)
         if len(table) != 1:
             raise ValueError(f'快照接口调用无数据: {data}')
         d = table[0]
@@ -337,7 +383,7 @@ class Futu(SecuritiesBroker):
             )
         if ret != RET_OK:
             raise Exception(f'下单失败: {data}')
-        orders = self.df_to_dict(data)
+        orders = self._df_to_list(data)
         assert len(orders) == 1
         order_id = orders[0]['order_id']
         assert order_id
@@ -365,9 +411,9 @@ class Futu(SecuritiesBroker):
             **kwargs
         ))
 
-    def _order(self, order_id: str) -> Order:
-        from futu import RET_OK, OrderStatus
-
+    @classmethod
+    def _build_order(cls, futu_order: dict) -> Order:
+        from futu import OrderStatus
         """
         富途证券的状态定义
         NONE = "N/A"                                # 未知状态
@@ -394,22 +440,11 @@ class Futu(SecuritiesBroker):
             OrderStatus.FAILED,
             OrderStatus.DISABLED,
             OrderStatus.DELETED,
-            OrderStatus.FILL_CANCELLED, # 不清楚对于成交数量有何影响.
+            OrderStatus.FILL_CANCELLED,  # 不清楚对于成交数量有何影响.
         }
         pending_cancel_sets = {OrderStatus.CANCELLING_PART, OrderStatus.CANCELLING_ALL, }
 
-        with self._refresh_order_bucket:
-            ret, data = self._trade_client.order_list_query(
-                order_id=order_id,
-                refresh_cache=True,
-                trd_env=self._trd_env,
-            )
-        if ret != RET_OK:
-            raise Exception(f'调用获取订单失败, 订单: {order_id}')
-        orders = self.df_to_dict(data)
-        if len(orders) != 1:
-            raise Exception(f'找不到订单(未完成), 订单: {order_id}')
-        futu_order = orders[0]
+        order_id = futu_order['order_id']
         reason = ''
         order_status: str = futu_order['order_status']
         if order_status in bad_endings:
@@ -427,6 +462,23 @@ class Futu(SecuritiesBroker):
             is_pending_cancel=is_pending_cancel,
         )
 
+    def _order(self, order_id: str) -> Order:
+        from futu import RET_OK
+
+        with self._refresh_order_bucket:
+            ret, data = self._trade_client.order_list_query(
+                order_id=order_id,
+                refresh_cache=True,
+                trd_env=self._trd_env,
+            )
+        if ret != RET_OK:
+            raise Exception(f'调用获取订单失败, 订单: {order_id}')
+        orders = self._df_to_list(data)
+        if len(orders) != 1:
+            raise Exception(f'找不到订单(未完成), 订单: {order_id}')
+        futu_order = orders[0]
+        return self._build_order(futu_order)
+
     async def order(self, order_id: str) -> Order:
         return await self.call_sync(lambda : self._order(order_id=order_id))
 

httptrading/broker/interactive_brokers.py

@@ -4,6 +4,7 @@ https://ib-insync.readthedocs.io/readme.html
 """
 import re
 import asyncio
+import nest_asyncio
 from typing import Any
 from httptrading.tool.leaky_bucket import *
 from httptrading.tool.time import *
@@ -29,9 +30,19 @@ class InteractiveBrokers(SecuritiesBroker):
     def _on_init(self):
         self._account_id = self.broker_args.get('account_id')
         self._client_id = self.broker_args.get('client_id')
+        nest_asyncio.apply()
 
     async def start(self):
         await self._try_create_client()
+        client = self._client
+        if HtGlobalConfig.DUMP_ACTIVE_ORDERS:
+            trades = client.trades()
+            for trade in trades:
+                try:
+                    order = self._build_order(trade)
+                    await self.call_sync(lambda: self.dump_order(order))
+                except Exception as ex:
+                    print(f'[{self.__class__.__name__}]DUMP_ACTIVE_ORDERS: {ex}\norder: {trade}')
 
     async def shutdown(self):
         ib_socket = self._client
@@ -86,7 +97,11 @@ class InteractiveBrokers(SecuritiesBroker):
         client: ib_insync.IB = client
 
         def _order_status_changed(trade: ib_insync.Trade):
-            pass
+            try:
+                order = self._build_order(trade)
+                self.dump_order(order)
+            except Exception as e:
+                print(f'[{self.__class__.__name__}]_order_status_changed: {e}\ntrade: {trade}')
 
         client.orderStatusEvent += _order_status_changed
 
@@ -193,7 +208,7 @@ class InteractiveBrokers(SecuritiesBroker):
             **kwargs
     ) -> str:
         import ib_insync
-        with self._order_bucket:
+        async with self._order_bucket:
             client = self._client
             ib_contract = await self.contract_to_ib_contract(contract)
 
@@ -274,7 +289,7 @@ class InteractiveBrokers(SecuritiesBroker):
 
     async def _cancel_order(self, order_id: str):
         order_id_int = int(order_id)
-        with self._order_bucket:
+        async with self._order_bucket:
             client = self._client
             trades = client.trades()
             for ib_trade in trades:
@@ -287,9 +302,9 @@ class InteractiveBrokers(SecuritiesBroker):
     async def cancel_order(self, order_id: str):
         await self.call_async(self._cancel_order(order_id=order_id))
 
-    async def _order(self, order_id: str) -> Order:
+    @classmethod
+    def _build_order(cls, ib_trade):
         import ib_insync
-
         canceled_endings = {ib_insync.OrderStatus.Cancelled, ib_insync.OrderStatus.ApiCancelled, }
         bad_endings = {ib_insync.OrderStatus.Inactive, }
         pending_cancel_sets = {ib_insync.OrderStatus.PendingCancel, }
@@ -304,7 +319,31 @@ class InteractiveBrokers(SecuritiesBroker):
             cap = sum([fill.execution.shares * fill.execution.avgPrice for fill in trade.fills], 0.0)
             return round(cap / total_fills, 5)
 
-        with self._order_bucket:
+        qty = int(_total_fills(ib_trade) + ib_trade.remaining())
+        filled_qty = _total_fills(ib_trade)
+        qty = qty or filled_qty
+        assert qty >= filled_qty
+        avg_fill_price = _avg_price(ib_trade)
+        reason = ''
+        if ib_trade.orderStatus.status in bad_endings:
+            reason = ib_trade.orderStatus.status
+        is_canceled = ib_trade.orderStatus.status in canceled_endings
+        is_pending_cancel = ib_trade.orderStatus.status in pending_cancel_sets
+        order_id = str(ib_trade.order.permId)
+        order = Order(
+            order_id=order_id,
+            currency=ib_trade.contract.currency,
+            qty=qty,
+            filled_qty=filled_qty,
+            avg_price=avg_fill_price,
+            error_reason=reason,
+            is_canceled=is_canceled,
+            is_pending_cancel=is_pending_cancel,
+        )
+        return order
+
+    async def _order(self, order_id: str) -> Order:
+        async with self._order_bucket:
             client = self._client
             trades = client.trades()
         order_id_int = int(order_id)
@@ -312,26 +351,7 @@ class InteractiveBrokers(SecuritiesBroker):
             ib_order = ib_trade.order
             if ib_order.permId != order_id_int:
                 continue
-            qty = int(_total_fills(ib_trade) + ib_trade.remaining())
-            filled_qty = _total_fills(ib_trade)
-            qty = qty or filled_qty
-            assert qty >= filled_qty
-            avg_fill_price = _avg_price(ib_trade)
-            reason = ''
-            if ib_trade.orderStatus.status in bad_endings:
-                reason = ib_trade.orderStatus.status
-            is_canceled = ib_trade.orderStatus.status in canceled_endings
-            is_pending_cancel = ib_trade.orderStatus.status in pending_cancel_sets
-            order = Order(
-                order_id=order_id,
-                currency=ib_trade.contract.currency,
-                qty=qty,
-                filled_qty=filled_qty,
-                avg_price=avg_fill_price,
-                error_reason=reason,
-                is_canceled=is_canceled,
-                is_pending_cancel=is_pending_cancel,
-            )
+            order = self._build_order(ib_trade)
             return order
         raise Exception(f'查询不到订单{order_id}')
 

httptrading/broker/longbridge.py

@@ -116,6 +116,58 @@ class LongBridge(SecuritiesBroker):
         self._lp_config = config
         self._quote_client = quote_ctx
         self._trade_client = trade_ctx
+        self._when_create_client()
+
+    @classmethod
+    def _order_status(cls, lp_order):
+        # 订单状态定义见
+        # https://open.longportapp.com/zh-CN/docs/trade/trade-definition#orderstatus
+        from longport.openapi import OrderStatus, PushOrderChanged, OrderDetail
+
+        canceled_endings = {OrderStatus.Canceled, }
+        bad_endings = {
+            OrderStatus.Rejected,
+            OrderStatus.Expired,
+            OrderStatus.PartialWithdrawal,
+        }
+        pending_cancel_sets = {OrderStatus.PendingCancel, }
+
+        if isinstance(lp_order, PushOrderChanged):
+            status = lp_order.status
+        elif isinstance(lp_order, OrderDetail):
+            status = lp_order.status
+        else:
+            raise Exception(f'{lp_order}对象不是已知可解析订单状态的类型')
+        reason = ''
+        if status in bad_endings:
+            reason = str(status)
+        is_canceled = status in canceled_endings
+        is_pending_cancel = status in pending_cancel_sets
+        return reason, is_canceled, is_pending_cancel
+
+    def _when_create_client(self):
+        from longport.openapi import PushOrderChanged, TopicType, OrderStatus
+
+        def _on_order_changed(event: PushOrderChanged):
+            reason, is_canceled, is_pending_cancel = self._order_status(event)
+            try:
+                order = Order(
+                    order_id=event.order_id,
+                    currency=event.currency,
+                    qty=int(event.executed_quantity),
+                    filled_qty=int(event.executed_quantity),
+                    avg_price=float(event.executed_price) if event.executed_price else 0.0,
+                    error_reason=reason,
+                    is_canceled=is_canceled,
+                    is_pending_cancel=is_pending_cancel,
+                )
+                self.dump_order(order)
+            except Exception as e:
+                print(f'[{self.__class__.__name__}]_on_order_changed: {e}\norder: {event}')
+
+        trade_client = self._trade_client
+        trade_client.set_on_order_changed(_on_order_changed)
+        trade_client.subscribe([TopicType.Private])
 
     def _try_refresh(self):
         if not self._auto_refresh_token:
@@ -344,26 +396,10 @@ class LongBridge(SecuritiesBroker):
         ))
 
     def _order(self, order_id: str) -> Order:
-        # 订单状态定义见
-        # https://open.longportapp.com/zh-CN/docs/trade/trade-definition#orderstatus
-        from longport.openapi import OrderStatus
-
-        canceled_endings = {OrderStatus.Canceled, }
-        bad_endings = {
-            OrderStatus.Rejected,
-            OrderStatus.Expired,
-            OrderStatus.PartialWithdrawal,
-        }
-        pending_cancel_sets = {OrderStatus.PendingCancel, }
-
         with self._assets_bucket:
             self._try_refresh()
             resp = self._trade_client.order_detail(order_id=order_id)
-        reason = ''
-        if resp.status in bad_endings:
-            reason = str(resp.status)
-        is_canceled = resp.status in canceled_endings
-        is_pending_cancel = resp.status in pending_cancel_sets
+        reason, is_canceled, is_pending_cancel = self._order_status(resp)
         return Order(
             order_id=order_id,
             currency=resp.currency,

httptrading/broker/tiger.py

@@ -46,6 +46,62 @@ class Tiger(SecuritiesBroker):
         self._trade_client = self._trade_client or TradeClient(client_config)
         protocol, host, port = client_config.socket_host_port
         self._push_client = self._push_client or PushClient(host, port, use_ssl=(protocol == 'ssl'))
+        self._when_create_client()
+
+    @classmethod
+    def _order_status(cls, tiger_order):
+        # 订单状态定义见
+        # https://quant.itigerup.com/openapi/zh/python/appendix2/overview.html#%E8%AE%A2%E5%8D%95%E7%8A%B6%E6%80%81
+        # 注意文档比 SDK 定义要少
+        from tigeropen.trade.domain.order import Order as TigerOrder, OrderStatus
+        from tigeropen.push.pb.OrderStatusData_pb2 import OrderStatusData
+        from tigeropen.common.util.order_utils import get_order_status
+
+        canceled_endings = {OrderStatus.CANCELLED, }
+        bad_endings = {
+            OrderStatus.REJECTED,
+            OrderStatus.EXPIRED,
+        }
+        pending_cancel_sets = {OrderStatus.PENDING_CANCEL, }
+
+        if isinstance(tiger_order, TigerOrder):
+            status = tiger_order.status
+        elif isinstance(tiger_order, OrderStatusData):
+            status = get_order_status(tiger_order.status)
+        else:
+            raise Exception(f'{tiger_order}对象不是已知可解析订单状态的类型')
+        reason = ''
+        if status in bad_endings:
+            reason = str(status)
+        is_canceled = status in canceled_endings
+        is_pending_cancel = status in pending_cancel_sets
+        return reason, is_canceled, is_pending_cancel
+
+    def _when_create_client(self):
+        from tigeropen.push.pb.OrderStatusData_pb2 import OrderStatusData
+
+        def _on_order_changed(frame: OrderStatusData):
+            try:
+                reason, is_canceled, is_pending_cancel = self._order_status(frame)
+                order = Order(
+                    order_id=str(frame.id),
+                    currency=frame.currency,
+                    qty=frame.totalQuantity or 0,
+                    filled_qty=frame.filledQuantity or 0,
+                    avg_price=frame.avgFillPrice or 0.0,
+                    error_reason=reason,
+                    is_canceled=is_canceled,
+                    is_pending_cancel=is_pending_cancel,
+                )
+                self.dump_order(order)
+            except Exception as e:
+                print(f'[{self.__class__.__name__}]_on_order_changed: {e}\norder: {frame}')
+
+        client_config = self._config
+        push_client = self._push_client
+        push_client.order_changed = _on_order_changed
+        push_client.connect(client_config.tiger_id, client_config.private_key)
+        push_client.subscribe_order(account=client_config.account)
 
     def _grab_quote(self):
         with self._grab_lock:
@@ -318,27 +374,14 @@ class Tiger(SecuritiesBroker):
         ))
 
     def _order(self, order_id: str) -> Order:
-        # 订单状态定义见
-        # https://quant.itigerup.com/openapi/zh/python/appendix2/overview.html#%E8%AE%A2%E5%8D%95%E7%8A%B6%E6%80%81
-        # 注意文档比 SDK 定义要少
-        from tigeropen.trade.domain.order import Order as TigerOrder, OrderStatus
-
-        canceled_endings = {OrderStatus.CANCELLED, }
-        bad_endings = {
-            OrderStatus.REJECTED,
-            OrderStatus.EXPIRED,
-        }
-        pending_cancel_sets = {OrderStatus.PENDING_CANCEL, }
+        from tigeropen.trade.domain.order import Order as TigerOrder
 
         with self._order_bucket:
             tiger_order: TigerOrder = self._trade_client.get_order(id=int(order_id))
         if tiger_order is None:
             raise Exception(f'查询不到订单{order_id}')
 
-        order_status = tiger_order.status
-        reason = tiger_order.reason or (order_status.name if order_status in bad_endings else None)
-        is_canceled = order_status in canceled_endings
-        is_pending_cancel = order_status in pending_cancel_sets
+        reason, is_canceled, is_pending_cancel = self._order_status(tiger_order)
         return Order(
             order_id=order_id,
             currency=tiger_order.contract.currency,