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

httptrading/__init__.py

@@ -1,6 +1,7 @@
 from httptrading.broker.base import *
-from httptrading.broker.futu import *
+from httptrading.broker.futu_sec import *
 from httptrading.broker.longbridge import *
 from httptrading.broker.tiger import *
 from httptrading.broker.interactive_brokers import *
-from httptrading.http_server import run
+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.py → 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,10 +411,60 @@ class Futu(SecuritiesBroker):
             **kwargs
         ))
 
+    @classmethod
+    def _build_order(cls, futu_order: dict) -> Order:
+        from futu import OrderStatus
+        """
+        富途证券的状态定义
+        NONE = "N/A"                                # 未知状态
+        UNSUBMITTED = "UNSUBMITTED"                 # 未提交
+        WAITING_SUBMIT = "WAITING_SUBMIT"           # 等待提交
+        SUBMITTING = "SUBMITTING"                   # 提交中
+        SUBMIT_FAILED = "SUBMIT_FAILED"             # 提交失败，下单失败
+        TIMEOUT = "TIMEOUT"                         # 处理超时，结果未知
+        SUBMITTED = "SUBMITTED"                     # 已提交，等待成交
+        FILLED_PART = "FILLED_PART"                 # 部分成交
+        FILLED_ALL = "FILLED_ALL"                   # 全部已成
+        CANCELLING_PART = "CANCELLING_PART"         # 正在撤单_部分(部分已成交，正在撤销剩余部分)
+        CANCELLING_ALL = "CANCELLING_ALL"           # 正在撤单_全部
+        CANCELLED_PART = "CANCELLED_PART"           # 部分成交，剩余部分已撤单
+        CANCELLED_ALL = "CANCELLED_ALL"             # 全部已撤单，无成交
+        FAILED = "FAILED"                           # 下单失败，服务拒绝
+        DISABLED = "DISABLED"                       # 已失效
+        DELETED = "DELETED"                         # 已删除，无成交的订单才能删除
+        FILL_CANCELLED = "FILL_CANCELLED"           # 成交被撤销，一般遇不到，意思是已经成交的订单被回滚撤销，成交无效变为废单
+        """
+        canceled_endings = {OrderStatus.CANCELLED_ALL, OrderStatus.CANCELLED_PART, }
+        bad_endings = {
+            OrderStatus.SUBMIT_FAILED,
+            OrderStatus.FAILED,
+            OrderStatus.DISABLED,
+            OrderStatus.DELETED,
+            OrderStatus.FILL_CANCELLED,  # 不清楚对于成交数量有何影响.
+        }
+        pending_cancel_sets = {OrderStatus.CANCELLING_PART, OrderStatus.CANCELLING_ALL, }
+
+        order_id = futu_order['order_id']
+        reason = ''
+        order_status: str = futu_order['order_status']
+        if order_status in bad_endings:
+            reason = order_status
+        is_canceled = order_status in canceled_endings
+        is_pending_cancel = order_status in pending_cancel_sets
+        return Order(
+            order_id=order_id,
+            currency=futu_order['currency'],
+            qty=int(futu_order['qty']),
+            filled_qty=int(futu_order['dealt_qty']),
+            avg_price=futu_order['dealt_avg_price'] or 0.0,
+            error_reason=reason,
+            is_canceled=is_canceled,
+            is_pending_cancel=is_pending_cancel,
+        )
+
     def _order(self, order_id: str) -> Order:
-        from futu import RET_OK, OrderStatus
-        error_set = {OrderStatus.FAILED, OrderStatus.DISABLED, OrderStatus.DELETED, }
-        cancel_set = {OrderStatus.CANCELLED_PART, OrderStatus.CANCELLED_ALL, }
+        from futu import RET_OK
+
         with self._refresh_order_bucket:
             ret, data = self._trade_client.order_list_query(
                 order_id=order_id,
@@ -377,22 +473,11 @@ class Futu(SecuritiesBroker):
             )
         if ret != RET_OK:
             raise Exception(f'调用获取订单失败, 订单: {order_id}')
-        orders = self.df_to_dict(data)
+        orders = self._df_to_list(data)
         if len(orders) != 1:
             raise Exception(f'找不到订单(未完成), 订单: {order_id}')
         futu_order = orders[0]
-        reason = ''
-        if futu_order['order_status'] in error_set:
-            reason = futu_order['order_status']
-        return Order(
-            order_id=order_id,
-            currency=futu_order['currency'],
-            qty=int(futu_order['qty']),
-            filled_qty=int(futu_order['dealt_qty']),
-            avg_price=futu_order['dealt_avg_price'] or 0.0,
-            error_reason=reason,
-            is_canceled=futu_order['order_status'] in cancel_set,
-        )
+        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,8 +4,8 @@ https://ib-insync.readthedocs.io/readme.html
 """
 import re
 import asyncio
+import nest_asyncio
 from typing import Any
-from collections import defaultdict
 from httptrading.tool.leaky_bucket import *
 from httptrading.tool.time import *
 from httptrading.broker.base import *
@@ -30,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
@@ -87,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
 
@@ -194,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)
 
@@ -275,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:
@@ -288,8 +302,12 @@ 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, }
 
         def _total_fills(trade) -> int:
             return int(trade.filled())
@@ -301,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)
@@ -309,26 +351,8 @@ 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 == ib_insync.OrderStatus.Inactive:
-                reason = 'Inactive'
-
-            cancel_status = {ib_insync.OrderStatus.Cancelled, ib_insync.OrderStatus.ApiCancelled, }
-            is_cancelled = ib_trade.orderStatus.status in cancel_status
-            return 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_cancelled,
-            )
+            order = self._build_order(ib_trade)
+            return order
         raise Exception(f'查询不到订单{order_id}')
 
     async def order(self, order_id: str) -> Order:

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,17 +396,10 @@ class LongBridge(SecuritiesBroker):
         ))
 
     def _order(self, order_id: str) -> Order:
-        from longport.openapi import OrderStatus
         with self._assets_bucket:
             self._try_refresh()
             resp = self._trade_client.order_detail(order_id=order_id)
-        reason = ''
-        if resp.status == OrderStatus.Rejected:
-            reason = '已拒绝'
-        if resp.status == OrderStatus.Expired:
-            reason = '已过期'
-        if resp.status == OrderStatus.PartialWithdrawal:
-            reason = '部分撤单'
+        reason, is_canceled, is_pending_cancel = self._order_status(resp)
         return Order(
             order_id=order_id,
             currency=resp.currency,
@@ -362,7 +407,8 @@ class LongBridge(SecuritiesBroker):
             filled_qty=int(resp.executed_quantity),
             avg_price=float(resp.executed_price) if resp.executed_price else 0.0,
             error_reason=reason,
-            is_canceled=resp.status == OrderStatus.Canceled,
+            is_canceled=is_canceled,
+            is_pending_cancel=is_pending_cancel,
         )
 
     async def order(self, order_id: str) -> Order:

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,19 +374,23 @@ class Tiger(SecuritiesBroker):
         ))
 
     def _order(self, order_id: str) -> Order:
-        from tigeropen.trade.domain.order import Order as TigerOrder, OrderStatus
+        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}')
+
+        reason, is_canceled, is_pending_cancel = self._order_status(tiger_order)
         return Order(
             order_id=order_id,
             currency=tiger_order.contract.currency,
             qty=tiger_order.quantity or 0,
             filled_qty=tiger_order.filled or 0,
             avg_price=tiger_order.avg_fill_price or 0.0,
-            error_reason=tiger_order.reason,
-            is_canceled=tiger_order.status == OrderStatus.CANCELLED,
+            error_reason=reason,
+            is_canceled=is_canceled,
+            is_pending_cancel=is_pending_cancel,
         )
 
     async def order(self, order_id: str) -> Order: