httptrading 1.0.0__py3-none-any.whl

httptrading/__init__.py

@@ -0,0 +1,6 @@
+from httptrading.broker.base import *
+from httptrading.broker.futu import *
+from httptrading.broker.longbridge import *
+from httptrading.broker.tiger import *
+from httptrading.broker.interactive_brokers import *
+from httptrading.http_server import run

httptrading/broker/base.py

@@ -0,0 +1,151 @@
+import asyncio
+import importlib
+from abc import ABC
+from typing import Type, Callable, Any
+from httptrading.model import *
+
+
+class BaseBroker(ABC):
+    def __init__(self, broker_args: dict = None, instance_id: str = None, tokens: list[str] = None):
+        self.detect_package()
+        self.broker_args = broker_args or dict()
+        self.instance_id = instance_id or ''
+        self.tokens: set[str] = set(tokens or list())
+        assert '' not in self.tokens
+
+    @property
+    def broker_name(self):
+        return BrokerRegister.get_meta(type(self)).name
+
+    @property
+    def broker_display(self):
+        return BrokerRegister.get_meta(type(self)).display
+
+    def detect_package(self):
+        pkg_info = BrokerRegister.get_meta(type(self)).detect_package
+        if pkg_info is None:
+            return
+        try:
+            importlib.import_module(pkg_info.import_name)
+        except ImportError:
+            raise ImportError(f'需要安装依赖包: {pkg_info.pkg_name}')
+
+    async def start(self):
+        pass
+
+    async def shutdown(self):
+        pass
+
+    async def call_sync(self, f: Callable[[], Any]):
+        try:
+            r = await asyncio.get_running_loop().run_in_executor(None, f)
+            return r
+        except Exception as ex:
+            raise BrokerError(self, ex)
+
+    async def call_async(self, coro):
+        try:
+            r = await coro
+            return r
+        except Exception as ex:
+            raise BrokerError(self, ex)
+
+    async def place_order(
+            self,
+            contract: Contract,
+            order_type: OrderType,
+            time_in_force: TimeInForce,
+            lifecycle: Lifecycle,
+            direction: str,
+            qty: int,
+            price: float = None,
+            **kwargs
+    ) -> str:
+        raise NotImplementedError
+
+    async def order(self, order_id: str) -> Order:
+        raise NotImplementedError
+
+    async def cancel_order(self, order_id: str):
+        raise NotImplementedError
+
+    async def positions(self) -> list[Position]:
+        raise NotImplementedError
+
+    async def cash(self) -> Cash:
+        raise NotImplementedError
+
+    async def ping(self) -> bool:
+        return True
+
+    async def quote(self, contract: Contract) -> Quote:
+        raise NotImplementedError
+
+    async def market_status(self) -> dict[str, dict[str, MarketStatus]]:
+        raise NotImplementedError
+
+
+class SecuritiesBroker(BaseBroker):
+    @classmethod
+    def contract_to_tz(cls, contract: Contract) -> str:
+        region = contract.region
+        match region:
+            case 'CN':
+                return 'Asia/Shanghai'
+            case 'HK':
+                return 'Asia/Hong_Kong'
+            case 'US':
+                return 'US/Eastern'
+            case _:
+                raise Exception(f'不能映射{contract}为已知时区')
+
+    @classmethod
+    def contract_to_currency(cls, contract: Contract) -> str | None:
+        region = contract.region
+        match region:
+            case 'CN':
+                return 'CNY'
+            case 'HK':
+                return 'HKD'
+            case 'US':
+                return 'USD'
+            case _:
+                raise Exception(f'不能映射{contract}为已知币种')
+
+
+class BrokerRegister:
+    _D: dict[str, Type[BaseBroker]] = dict()
+    _META: dict[str, BrokerMeta] = dict()
+
+    @classmethod
+    def register(cls, broker_class: Type[BaseBroker], name: str, display: str, detect_pkg: DetectPkg = None):
+        type_name = broker_class.__name__
+        if type_name in cls._D:
+            raise ValueError(f"Duplicate broker class name '{type_name}'")
+        cls._D[type_name] = broker_class
+        cls._META[type_name] = BrokerMeta(name=name, display=display, detect_package=detect_pkg)
+
+    @classmethod
+    def get_meta(cls, broker_class: Type[BaseBroker]) -> BrokerMeta:
+        return BrokerRegister._META.get(broker_class.__name__)
+
+
+def broker_register(name: str, display: str, detect_pkg: DetectPkg = None):
+    def decorator(cls: Type[BaseBroker]):
+        BrokerRegister.register(cls, name, display, detect_pkg)
+        return cls
+    return decorator
+
+
+class BrokerError(ValueError):
+    def __init__(self, broker: BaseBroker, ex, *args, **kwargs):
+        self.broker = broker
+        super().__init__(f'[{broker.instance_id}]<{broker.broker_name} {broker.broker_display}>异常: {ex}')
+
+
+__all__ = [
+    'BaseBroker',
+    'SecuritiesBroker',
+    'broker_register',
+    'BrokerError',
+]

httptrading/broker/futu.py

@@ -0,0 +1,418 @@
+"""
+接入富途证券的API文档
+https://openapi.futunn.com/futu-api-doc/
+"""
+import re
+from datetime import datetime
+from httptrading.tool.leaky_bucket import *
+from httptrading.broker.base import *
+from httptrading.model import *
+from httptrading.tool.time import *
+
+
+@broker_register(name='futu', display='富途证券', detect_pkg=DetectPkg('futu-api', 'futu'))
+class Futu(SecuritiesBroker):
+    def __init__(self, broker_args: dict = None, instance_id: str = None, tokens: list[str] = None):
+        super().__init__(broker_args, instance_id, tokens)
+        self._unlock_pin = ''
+        self._trd_env = 'REAL'
+        self._quote_client = None
+        self._trade_client = None
+        self._market_status_bucket = LeakyBucket(10)
+        self._snapshot_bucket = LeakyBucket(120)
+        self._assets_bucket = LeakyBucket(20)
+        self._position_bucket = LeakyBucket(20)
+        self._unlock_bucket = LeakyBucket(20)
+        self._place_order_bucket = LeakyBucket(30)
+        self._cancel_order_bucket = LeakyBucket(30)
+        self._refresh_order_bucket = LeakyBucket(20)
+        self._on_init()
+
+    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', '')
+        self._unlock_pin = config_dict.get('unlock_pin', '')
+        if pk_path:
+            SysConfig.enable_proto_encrypt(is_encrypt=True)
+            SysConfig.set_init_rsa_file(pk_path)
+        if self._trade_client is None:
+            SysConfig.set_all_thread_daemon(True)
+            host = config_dict.get('host', '127.0.0.1')
+            port = config_dict.get('port', 11111)
+            trade_ctx = OpenSecTradeContext(
+                filter_trdmarket=TrdMarket.US,
+                host=host,
+                port=port,
+                security_firm=SecurityFirm.FUTUSECURITIES,
+            )
+            trade_ctx.set_sync_query_connect_timeout(6.0)
+            self._trade_client = trade_ctx
+        if self._quote_client is None:
+            SysConfig.set_all_thread_daemon(True)
+            host = config_dict.get('host', '127.0.0.1')
+            port = config_dict.get('port', 11111)
+            quote_ctx = OpenQuoteContext(host=host, port=port)
+            quote_ctx.set_sync_query_connect_timeout(6.0)
+            self._quote_client = quote_ctx
+
+    @classmethod
+    def code_to_contract(cls, code) -> Contract | None:
+        region = ''
+        ticker = ''
+        if m := re.match(r'^US\.(\S+)$', code):
+            region = 'US'
+            ticker = m.groups()[0]
+        if m := re.match(r'^HK\.(\d{5})$', code):
+            region = 'HK'
+            ticker = m.groups()[0]
+        if m := re.match(r'^SH\.(\d{6})$', code):
+            region = 'CN'
+            ticker = m.groups()[0]
+        if m := re.match(r'^SZ\.(\d{6})$', code):
+            region = 'CN'
+            ticker = m.groups()[0]
+        if not region or not ticker:
+            return None
+        return Contract(
+            trade_type=TradeType.Securities,
+            ticker=ticker,
+            region=region,
+        )
+
+    @classmethod
+    def contract_to_code(cls, contract: Contract) -> str | None:
+        if contract.trade_type != TradeType.Securities:
+            return None
+        region, ticker = contract.region, contract.ticker
+        code = None
+        if region == 'CN' and re.match(r'^[56]\d{5}$', ticker):
+            code = f'SH.{ticker}'
+        elif region == 'CN' and re.match(r'^[013]\d{5}$', ticker):
+            code = f'SZ.{ticker}'
+        elif region == 'HK' and re.match(r'^\d{5}$', ticker):
+            code = f'HK.{ticker}'
+        elif region == 'US' and re.match(r'^\w+$', ticker):
+            code = f'US.{ticker}'
+        return code
+
+    @classmethod
+    def df_to_dict(cls, df) -> dict:
+        return df.to_dict(orient='records')
+
+    def _positions(self):
+        result = list()
+        from futu import RET_OK
+        with self._position_bucket:
+            resp, data = self._trade_client.position_list_query(
+                trd_env=self._trd_env,
+                refresh_cache=True,
+            )
+        if resp != RET_OK:
+            raise Exception(f'返回失败: {resp}')
+        positions = self.df_to_dict(data)
+        for d in positions:
+            code = d.get('code')
+            currency = d.get('currency')
+            if not code or not currency:
+                continue
+            contract = self.code_to_contract(code)
+            if not contract:
+                continue
+            qty = int(d['qty'])
+            position = Position(
+                broker=self.broker_name,
+                broker_display=self.broker_display,
+                contract=contract,
+                unit=Unit.Share,
+                currency=currency,
+                qty=qty,
+            )
+            result.append(position)
+        return result
+
+    async def positions(self):
+        return await self.call_sync(lambda : self._positions())
+
+    async def ping(self) -> bool:
+        try:
+            client = self._trade_client
+            conn_id = client.get_sync_conn_id()
+            return bool(conn_id)
+        except Exception as e:
+            return False
+
+    def _cash(self) -> Cash:
+        from futu import RET_OK, Currency
+        with self._assets_bucket:
+            resp, data = self._trade_client.accinfo_query(
+                trd_env=self._trd_env,
+                refresh_cache=True,
+                currency=Currency.USD,
+            )
+        if resp != RET_OK:
+            raise Exception(f'可用资金信息获取失败: {data}')
+        assets = self.df_to_dict(data)
+        if len(assets) == 1:
+            cash = Cash(
+                currency='USD',
+                amount=assets[0]['cash'],
+            )
+            return cash
+        else:
+            raise Exception(f'可用资金信息获取不到记录')
+
+    async def cash(self) -> Cash:
+        return await self.call_sync(lambda : self._cash())
+
+    def _market_status(self) -> dict[str, dict[str, MarketStatus]]:
+        # 各个市场的状态定义见:
+        # https://openapi.futunn.com/futu-api-doc/qa/quote.html#2090
+        from futu import RET_OK
+        sec_result = dict()
+        region_map = {
+            'market_sh': 'CN',
+            'market_hk': 'HK',
+            'market_us': 'US',
+        }
+        status_map = {
+            'CLOSED': UnifiedStatus.CLOSED,
+            'PRE_MARKET_BEGIN': UnifiedStatus.PRE_HOURS,
+            'MORNING': UnifiedStatus.RTH,
+            'AFTERNOON': UnifiedStatus.RTH,
+            'AFTER_HOURS_BEGIN': UnifiedStatus.AFTER_HOURS,
+            'AFTER_HOURS_END': UnifiedStatus.CLOSED, # 根据文档, 盘后收盘时段跟夜盘时段重合
+            'OVERNIGHT': UnifiedStatus.OVERNIGHT,
+            # 这些映射是A股港股市场的映射
+            'REST': UnifiedStatus.REST,
+            'HK_CAS': UnifiedStatus.CLOSED,
+        }
+        client = self._quote_client
+        with self._market_status_bucket:
+            ret, data = client.get_global_state()
+        if ret != RET_OK:
+            raise Exception(f'市场状态接口调用失败: {data}')
+        for k, origin_status in data.items():
+            if k not in region_map:
+                continue
+            region = region_map[k]
+            unified_status = status_map.get(origin_status, UnifiedStatus.UNKNOWN)
+            sec_result[region] = MarketStatus(
+                region=region,
+                origin_status=origin_status,
+                unified_status=unified_status,
+            )
+        return {
+            TradeType.Securities.name.lower(): sec_result,
+        }
+
+    async def market_status(self) -> dict[str, dict[str, MarketStatus]]:
+        return await self.call_sync(lambda : self._market_status())
+
+    def _quote(self, contract: Contract):
+        from futu import RET_OK
+        tz = self.contract_to_tz(contract)
+        code = self.contract_to_code(contract)
+        currency = self.contract_to_currency(contract)
+        with self._snapshot_bucket:
+            ret, data = self._quote_client.get_market_snapshot([code, ])
+        if ret != RET_OK:
+            raise ValueError(f'快照接口调用失败: {data}')
+        table = self.df_to_dict(data)
+        if len(table) != 1:
+            raise ValueError(f'快照接口调用无数据: {data}')
+        d = table[0]
+        """
+        格式：yyyy-MM-dd HH:mm:ss
+        港股和 A 股市场默认是北京时间，美股市场默认是美东时间
+        """
+        update_time: str = d['update_time']
+        update_dt = datetime.strptime(update_time, '%Y-%m-%d %H:%M:%S')
+        update_dt = TimeTools.from_params(
+            year=update_dt.year,
+            month=update_dt.month,
+            day=update_dt.day,
+            hour=update_dt.hour,
+            minute=update_dt.minute,
+            second=update_dt.second,
+            tz=tz,
+        )
+        is_tradable = d['sec_status'] == 'NORMAL'
+        return Quote(
+            contract=contract,
+            currency=currency,
+            is_tradable=is_tradable,
+            latest=d['last_price'],
+            pre_close=d['prev_close_price'],
+            open_price=d['open_price'],
+            high_price=d['high_price'],
+            low_price=d['low_price'],
+            time=update_dt,
+        )
+
+    async def quote(self, contract: Contract):
+        return await self.call_sync(lambda : self._quote(contract))
+
+    def _try_unlock(self):
+        from futu import RET_OK, TrdEnv
+        if self._trd_env != TrdEnv.REAL:
+            return
+        if not self._unlock_pin:
+            return
+        with self._unlock_bucket:
+            ret, data = self._trade_client.unlock_trade(password_md5=self._unlock_pin)
+        if ret != RET_OK:
+            raise Exception(f'解锁交易失败: {data}')
+
+    def _place_order(
+            self,
+            contract: Contract,
+            order_type: OrderType,
+            time_in_force: TimeInForce,
+            lifecycle: Lifecycle,
+            direction: str,
+            qty: int,
+            price: float = None,
+            **kwargs
+    ) -> str:
+        from futu import RET_OK, TrdSide, OrderType as FutuOrderType, TimeInForce as FutuTimeInForce, Session
+        if contract.trade_type != TradeType.Securities:
+            raise Exception(f'不支持的下单品种: {contract.trade_type}')
+        if contract.region == 'US' and order_type == OrderType.Market and lifecycle != Lifecycle.RTH:
+            raise Exception(f'交易时段不支持市价单')
+        code = self.contract_to_code(contract)
+        assert qty > 0
+        assert price > 0
+
+        def _map_trade_side():
+            match direction:
+                case 'BUY':
+                    return TrdSide.BUY
+                case 'SELL':
+                    return TrdSide.SELL
+                case _:
+                    raise Exception(f'不支持的买卖方向: {direction}')
+
+        def _map_order_type():
+            match order_type:
+                case OrderType.Market:
+                    return FutuOrderType.MARKET
+                case OrderType.Limit:
+                    return FutuOrderType.NORMAL
+                case _:
+                    raise Exception(f'不支持的订单类型: {order_type}')
+
+        def _map_time_in_force():
+            match time_in_force:
+                case TimeInForce.DAY:
+                    return FutuTimeInForce.DAY
+                case TimeInForce.GTC:
+                    return FutuTimeInForce.GTC
+                case _:
+                    raise Exception(f'不支持的订单有效期: {time_in_force}')
+
+        def _map_lifecycle():
+            match lifecycle:
+                case Lifecycle.RTH:
+                    return Session.RTH
+                case Lifecycle.ETH:
+                    return Session.ETH
+                case Lifecycle.OVERNIGHT:
+                    return Session.OVERNIGHT
+                case _:
+                    raise Exception(f'不支持的交易时段: {lifecycle}')
+
+        self._try_unlock()
+        with self._place_order_bucket:
+            ret, data = self._trade_client.place_order(
+                code=code,
+                price=price or 10.0, # 富途必须要填充这个字段
+                qty=qty,
+                trd_side=_map_trade_side(),
+                order_type=_map_order_type(),
+                time_in_force=_map_time_in_force(),
+                trd_env=self._trd_env,
+                session=_map_lifecycle(),
+            )
+        if ret != RET_OK:
+            raise Exception(f'下单失败: {data}')
+        orders = self.df_to_dict(data)
+        assert len(orders) == 1
+        order_id = orders[0]['order_id']
+        assert order_id
+        return order_id
+
+    async def place_order(
+            self,
+            contract: Contract,
+            order_type: OrderType,
+            time_in_force: TimeInForce,
+            lifecycle: Lifecycle,
+            direction: str,
+            qty: int,
+            price: float = None,
+            **kwargs
+    ) -> str:
+        return await self.call_sync(lambda : self._place_order(
+            contract=contract,
+            order_type=order_type,
+            time_in_force=time_in_force,
+            lifecycle=lifecycle,
+            direction=direction,
+            qty=qty,
+            price=price,
+            **kwargs
+        ))
+
+    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, }
+        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]
+        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,
+        )
+
+    async def order(self, order_id: str) -> Order:
+        return await self.call_sync(lambda : self._order(order_id=order_id))
+
+    def _cancel_order(self, order_id: str):
+        from futu import RET_OK, ModifyOrderOp
+        self._try_unlock()
+        with self._cancel_order_bucket:
+            ret, data = self._trade_client.modify_order(
+                modify_order_op=ModifyOrderOp.CANCEL,
+                order_id=order_id,
+                qty=100,
+                price=10.0,
+                trd_env=self._trd_env,
+            )
+        if ret != RET_OK:
+            raise Exception(f'撤单失败, 订单: {order_id}, 原因: {data}')
+
+    async def cancel_order(self, order_id: str):
+        await self.call_sync(lambda: self._cancel_order(order_id=order_id))
+
+
+__all__ = ['Futu', ]