aria-code 4.1.3__py3-none-any.whl

brokers/cn/futu_broker.py

@@ -0,0 +1,194 @@
+"""
+brokers/cn/futu_broker.py — 富途牛牛 OpenAPI 适配器
+=====================================================
+支持市场：港股、美股、A股（通过 OpenD 网关）
+
+安装：pip install futu-api
+文档：https://openapi.futunn.com/futu-api-doc/
+
+配置示例::
+
+    {
+      "id":     "futu_hk",
+      "type":   "futu",
+      "label":  "富途港股",
+      "host":   "127.0.0.1",
+      "port":   11111,
+      "market": "HK",
+      "trd_env": "REAL"
+    }
+
+注意：需在本机启动 Futu OpenD 进程。
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ..base import BrokerBase, AccountInfo, Position, Order, OrderResult
+
+
+class FutuBroker(BrokerBase):
+    broker_type = "futu"
+    broker_name = "富途牛牛"
+    market      = "HK"
+
+    def __init__(self, broker_id: str, config: Dict[str, Any]):
+        super().__init__(broker_id, config)
+        self._host    = config.get("host", "127.0.0.1")
+        self._port    = int(config.get("port", 11111))
+        self._market  = config.get("market", "HK").upper()
+        self._trd_env = config.get("trd_env", "REAL").upper()
+        self._quote_ctx = None
+        self._trd_ctx   = None
+        self.market = self._market
+
+    def connect(self) -> bool:
+        try:
+            import futu as ft
+        except ImportError:
+            raise ImportError("futu-api 未安装。请运行: pip install futu-api  并启动 Futu OpenD")
+
+        try:
+            self._quote_ctx = ft.OpenQuoteContext(host=self._host, port=self._port)
+            trd_market = {
+                "HK":  ft.TrdMarket.HK,
+                "US":  ft.TrdMarket.US,
+                "CN":  ft.TrdMarket.CN,
+                "A":   ft.TrdMarket.CN,
+            }.get(self._market, ft.TrdMarket.HK)
+            trd_env = ft.TrdEnv.REAL if self._trd_env == "REAL" else ft.TrdEnv.SIMULATE
+            self._trd_ctx = ft.OpenSecTradeContext(
+                filter_trdmarket=trd_market,
+                host=self._host, port=self._port,
+                security_firm=ft.SecurityFirm.FUTUINC,
+            )
+            self._ft      = ft
+            self._trd_env_val = trd_env
+            self._connected   = True
+            return True
+        except Exception as e:
+            raise RuntimeError(f"富途 OpenAPI 连接失败: {e}") from e
+
+    def disconnect(self) -> None:
+        for ctx in (self._quote_ctx, self._trd_ctx):
+            try:
+                if ctx:
+                    ctx.close()
+            except Exception:
+                pass
+        self._connected = False
+
+    def account_info(self) -> AccountInfo:
+        self._require_connected()
+        ret, data = self._trd_ctx.accinfo_query(trd_env=self._trd_env_val)
+        if ret != self._ft.RET_OK:
+            raise RuntimeError(f"富途账户查询失败: {data}")
+        row = data.iloc[0]
+        currency = "HKD" if self._market == "HK" else "USD" if self._market == "US" else "CNY"
+        return AccountInfo(
+            broker_id=self.broker_id,
+            broker_type=self.broker_type,
+            label=self.label,
+            account_id=str(row.get("acc_id", "")),
+            currency=currency,
+            total_assets=float(row.get("total_assets", 0)),
+            cash=float(row.get("cash", 0)),
+            market_value=float(row.get("market_val", 0)),
+            frozen=float(row.get("frozen_cash", 0)),
+            pnl_today=float(row.get("today_profit", 0)),
+            pnl_pct=float(row.get("today_profit_ratio", 0)) * 100,
+        )
+
+    def positions(self) -> List[Position]:
+        self._require_connected()
+        ret, data = self._trd_ctx.position_list_query(trd_env=self._trd_env_val)
+        if ret != self._ft.RET_OK:
+            raise RuntimeError(f"富途持仓查询失败: {data}")
+        result = []
+        currency = "HKD" if self._market == "HK" else "USD" if self._market == "US" else "CNY"
+        for _, row in data.iterrows():
+            sym  = str(row.get("code", ""))
+            name = str(row.get("stock_name", ""))
+            qty  = float(row.get("qty", 0))
+            avail= float(row.get("can_sell_qty", 0))
+            cost = float(row.get("cost_price", 0))
+            price= float(row.get("price",      0))
+            mv   = float(row.get("market_val", 0))
+            pnl  = float(row.get("unrealized_pl", 0))
+            pnl_pct = float(row.get("unrealized_pl_ratio", 0)) * 100
+            result.append(Position(
+                symbol=sym, name=name,
+                quantity=qty, available_qty=avail,
+                cost_price=cost, current_price=price,
+                market_value=mv, pnl=pnl, pnl_pct=pnl_pct,
+                currency=currency, market=self._market.lower(),
+            ))
+        return result
+
+    def orders(self, status: str = "all", limit: int = 50) -> List[Order]:
+        self._require_connected()
+        ret, data = self._trd_ctx.order_list_query(trd_env=self._trd_env_val)
+        if ret != self._ft.RET_OK:
+            raise RuntimeError(f"富途订单查询失败: {data}")
+        result = []
+        for _, row in data.head(limit).iterrows():
+            side     = "buy" if "BUY" in str(row.get("trd_side", "")).upper() else "sell"
+            raw_st   = str(row.get("order_status", ""))
+            mapped   = _futu_order_status(raw_st)
+            if status != "all" and mapped != status:
+                continue
+            result.append(Order(
+                order_id=str(row.get("order_id", "")),
+                symbol=str(row.get("code", "")),
+                name=str(row.get("stock_name", "")),
+                side=side,
+                order_type=str(row.get("order_type", "")).lower(),
+                quantity=float(row.get("qty", 0)),
+                filled_qty=float(row.get("dealt_qty", 0)),
+                price=float(row.get("price", 0)),
+                avg_price=float(row.get("dealt_avg_price", 0)),
+                status=mapped,
+                created_at=str(row.get("create_time", "")),
+            ))
+        return result
+
+    def place_order(self, symbol: str, side: str, quantity: float,
+                    order_type: str = "limit", price: float = 0.0, **kwargs) -> OrderResult:
+        self._require_connected()
+        ft = self._ft
+        trd_side = ft.TrdSide.BUY if side == "buy" else ft.TrdSide.SELL
+        ot = ft.OrderType.NORMAL if order_type == "limit" else ft.OrderType.MARKET
+        ret, data = self._trd_ctx.place_order(
+            price=price, qty=quantity, code=symbol,
+            trd_side=trd_side, order_type=ot,
+            trd_env=self._trd_env_val,
+        )
+        if ret != ft.RET_OK:
+            return OrderResult(success=False, message=str(data), broker_id=self.broker_id)
+        oid = str(data.iloc[0].get("order_id", ""))
+        return OrderResult(success=True, order_id=oid, broker_id=self.broker_id)
+
+    def cancel_order(self, order_id: str) -> bool:
+        self._require_connected()
+        ret, _ = self._trd_ctx.modify_order(
+            modify_order_op=self._ft.ModifyOrderOp.CANCEL,
+            order_id=int(order_id), qty=0, price=0,
+            trd_env=self._trd_env_val,
+        )
+        return ret == self._ft.RET_OK
+
+    def _require_connected(self):
+        if not self._connected or not self._trd_ctx:
+            raise RuntimeError("富途 OpenAPI 未连接，请先调用 connect()")
+
+
+def _futu_order_status(raw: str) -> str:
+    raw = raw.upper()
+    if "FILLED_ALL" in raw or "已全部成交" in raw:
+        return "filled"
+    if "FILLED_PART" in raw or "部分" in raw:
+        return "partial"
+    if "CANCELLED" in raw or "已撤" in raw:
+        return "cancelled"
+    return "open"

brokers/cn/longbridge_broker.py

@@ -0,0 +1,190 @@
+"""
+brokers/cn/longbridge_broker.py — 长桥证券 OpenAPI 适配器
+===========================================================
+支持市场：港股、美股、A股
+
+安装：pip install longbridge
+文档：https://open.longportapp.com/
+
+配置示例::
+
+    {
+      "id":           "lb_main",
+      "type":         "longbridge",
+      "label":        "长桥主账户",
+      "app_key":      "YOUR_APP_KEY",
+      "app_secret":   "YOUR_APP_SECRET",
+      "access_token": "YOUR_ACCESS_TOKEN"
+    }
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ..base import BrokerBase, AccountInfo, Position, Order, OrderResult
+
+
+class LongbridgeBroker(BrokerBase):
+    broker_type = "longbridge"
+    broker_name = "长桥证券"
+    market      = "GLOBAL"
+
+    def __init__(self, broker_id: str, config: Dict[str, Any]):
+        super().__init__(broker_id, config)
+        self._app_key      = config.get("app_key", "")
+        self._app_secret   = config.get("app_secret", "")
+        self._access_token = config.get("access_token", "")
+        self._trade_ctx    = None
+        self._quote_ctx    = None
+
+    def connect(self) -> bool:
+        try:
+            from longbridge.openapi import TradeContext, QuoteContext, Config
+        except ImportError:
+            raise ImportError("longbridge 未安装。请运行: pip install longbridge")
+
+        try:
+            cfg = Config(
+                app_key=self._app_key,
+                app_secret=self._app_secret,
+                access_token=self._access_token,
+            )
+            self._trade_ctx = TradeContext(cfg)
+            self._quote_ctx = QuoteContext(cfg)
+            # 测试连接
+            self._trade_ctx.account_balance()
+            self._connected = True
+            return True
+        except Exception as e:
+            raise RuntimeError(f"长桥证券连接失败: {e}") from e
+
+    def account_info(self) -> AccountInfo:
+        self._require_connected()
+        try:
+            resp = self._trade_ctx.account_balance()
+            bal  = resp[0] if resp else None
+            if not bal:
+                raise RuntimeError("长桥账户余额为空")
+            currency = str(getattr(bal, "currency", "HKD"))
+            total = float(getattr(bal, "total_cash", 0))
+            cash  = float(getattr(bal, "available_cash", 0))
+            mv    = float(getattr(bal, "market_value", 0))
+            pnl   = float(getattr(bal, "unrealized_pnl", 0))
+        except Exception as e:
+            raise RuntimeError(f"长桥账户查询失败: {e}") from e
+
+        return AccountInfo(
+            broker_id=self.broker_id,
+            broker_type=self.broker_type,
+            label=self.label,
+            account_id=self.config.get("account_id", self._app_key[-6:]),
+            currency=currency,
+            total_assets=total + mv,
+            cash=cash,
+            market_value=mv,
+            pnl_total=pnl,
+        )
+
+    def positions(self) -> List[Position]:
+        self._require_connected()
+        try:
+            raw = self._trade_ctx.stock_positions()
+        except Exception as e:
+            raise RuntimeError(f"长桥持仓查询失败: {e}") from e
+
+        result = []
+        for ch in getattr(raw, "channels", []):
+            for p in getattr(ch, "positions", []):
+                sym   = str(getattr(p, "symbol", ""))
+                name  = str(getattr(p, "symbol_name", ""))
+                qty   = float(getattr(p, "quantity", 0))
+                avail = float(getattr(p, "available_quantity", qty))
+                cost  = float(getattr(p, "cost_price", 0))
+                price = float(getattr(p, "current_price", 0))
+                mv    = float(getattr(p, "market_value", 0))
+                pnl   = float(getattr(p, "unrealized_pnl", 0))
+                pnl_pct = float(getattr(p, "unrealized_pnl_ratio", 0))
+                currency = str(getattr(p, "currency", "HKD"))
+                result.append(Position(
+                    symbol=sym, name=name,
+                    quantity=qty, available_qty=avail,
+                    cost_price=cost, current_price=price,
+                    market_value=mv, pnl=pnl, pnl_pct=pnl_pct * 100,
+                    currency=currency,
+                ))
+        return result
+
+    def orders(self, status: str = "all", limit: int = 50) -> List[Order]:
+        self._require_connected()
+        try:
+            from longbridge.openapi import OrderStatus as LBOrderStatus
+            raw = self._trade_ctx.today_orders()
+        except Exception as e:
+            raise RuntimeError(f"长桥订单查询失败: {e}") from e
+
+        result = []
+        for o in list(raw or [])[:limit]:
+            side   = "buy" if "BUY" in str(getattr(o, "side", "")).upper() else "sell"
+            mapped = _lb_order_status(str(getattr(o, "status", "")))
+            if status != "all" and mapped != status:
+                continue
+            result.append(Order(
+                order_id=str(getattr(o, "order_id", "")),
+                symbol=str(getattr(o, "symbol", "")),
+                name=str(getattr(o, "stock_name", "")),
+                side=side,
+                order_type=str(getattr(o, "order_type", "")).lower(),
+                quantity=float(getattr(o, "quantity", 0)),
+                filled_qty=float(getattr(o, "executed_quantity", 0)),
+                price=float(getattr(o, "price", 0)),
+                avg_price=float(getattr(o, "executed_price", 0)),
+                status=mapped,
+                created_at=str(getattr(o, "submitted_at", "")),
+                currency=str(getattr(o, "currency", "HKD")),
+            ))
+        return result
+
+    def place_order(self, symbol: str, side: str, quantity: float,
+                    order_type: str = "limit", price: float = 0.0, **kwargs) -> OrderResult:
+        self._require_connected()
+        try:
+            from longbridge.openapi import OrderSide, OrderType, TimeInForceType
+            from decimal import Decimal
+            lb_side = OrderSide.Buy if side == "buy" else OrderSide.Sell
+            lb_type = OrderType.MO if order_type == "market" else OrderType.LO
+            resp = self._trade_ctx.submit_order(
+                symbol=symbol,
+                order_type=lb_type,
+                side=lb_side,
+                submitted_quantity=int(quantity),
+                time_in_force=TimeInForceType.Day,
+                submitted_price=Decimal(str(price)) if price else None,
+            )
+            oid = str(getattr(resp, "order_id", ""))
+            return OrderResult(success=True, order_id=oid, broker_id=self.broker_id)
+        except Exception as e:
+            return OrderResult(success=False, message=str(e), broker_id=self.broker_id)
+
+    def cancel_order(self, order_id: str) -> bool:
+        self._require_connected()
+        try:
+            self._trade_ctx.cancel_order(order_id)
+            return True
+        except Exception:
+            return False
+
+    def _require_connected(self):
+        if not self._connected:
+            raise RuntimeError("长桥证券未连接，请先调用 connect()")
+
+
+def _lb_order_status(raw: str) -> str:
+    raw = raw.upper()
+    if "FILLED" in raw and "PARTIAL" not in raw:
+        return "filled"
+    if "PARTIAL" in raw:
+        return "partial"
+    if any(x in raw for x in ("CANCELLED", "EXPIRED", "REJECTED")):
+        return "cancelled"
+    return "open"

brokers/cn/tiger_broker.py

@@ -0,0 +1,196 @@
+"""
+brokers/cn/tiger_broker.py — 老虎证券 OpenAPI 适配器
+======================================================
+支持市场：美股、港股、A股
+
+安装：pip install tigeropen
+文档：https://quant.tigerfintech.com/
+
+配置示例::
+
+    {
+      "id":               "tiger_us",
+      "type":             "tiger",
+      "label":            "老虎美股",
+      "tiger_id":         "YOUR_TIGER_ID",
+      "private_key_path": "~/.arthera/tiger_rsa.pem",
+      "account":          "YOUR_ACCOUNT_ID",
+      "sandbox":          false
+    }
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+from ..base import BrokerBase, AccountInfo, Position, Order, OrderResult
+
+
+class TigerBroker(BrokerBase):
+    broker_type = "tiger"
+    broker_name = "老虎证券"
+    market      = "US"
+
+    def __init__(self, broker_id: str, config: Dict[str, Any]):
+        super().__init__(broker_id, config)
+        self._tiger_id       = config.get("tiger_id", "")
+        self._private_key_path = config.get("private_key_path", "")
+        self._account        = config.get("account", "")
+        self._sandbox        = bool(config.get("sandbox", False))
+        self._client_config  = None
+        self._trade_client   = None
+        self._quote_client   = None
+
+    def connect(self) -> bool:
+        try:
+            from tigeropen.tiger_open_config import TigerOpenClientConfig
+            from tigeropen.common.consts import TigerApiConstants
+            from tigeropen.trade.trade_client import TradeClient
+            from tigeropen.quote.quote_client import QuoteClient
+        except ImportError:
+            raise ImportError("tigeropen 未安装。请运行: pip install tigeropen")
+
+        import os
+        pk_path = os.path.expanduser(self._private_key_path)
+        if not os.path.exists(pk_path):
+            raise FileNotFoundError(f"老虎证券私钥文件不存在: {pk_path}")
+
+        try:
+            cfg = TigerOpenClientConfig(sandbox_debug=self._sandbox)
+            cfg.tiger_id    = self._tiger_id
+            cfg.private_key = open(pk_path).read()
+            cfg.account     = self._account
+            self._client_config  = cfg
+            self._trade_client   = TradeClient(cfg)
+            self._quote_client   = QuoteClient(cfg)
+            # 测试连接
+            self._trade_client.get_managed_accounts()
+            self._connected = True
+            return True
+        except Exception as e:
+            raise RuntimeError(f"老虎证券连接失败: {e}") from e
+
+    def account_info(self) -> AccountInfo:
+        self._require_connected()
+        try:
+            assets = self._trade_client.get_assets(account=self._account)
+            a = assets[0] if assets else None
+            if not a:
+                raise RuntimeError("老虎证券返回空账户数据")
+            return AccountInfo(
+                broker_id=self.broker_id,
+                broker_type=self.broker_type,
+                label=self.label,
+                account_id=self._account,
+                currency=str(getattr(a, "currency", "USD")),
+                total_assets=float(getattr(a, "net_liquidation", 0)),
+                cash=float(getattr(a, "cash_balance", 0)),
+                market_value=float(getattr(a, "gross_position_value", 0)),
+                pnl_today=float(getattr(a, "realized_pnl", 0)),
+                pnl_total=float(getattr(a, "unrealized_pnl", 0)),
+            )
+        except Exception as e:
+            raise RuntimeError(f"老虎证券账户查询失败: {e}") from e
+
+    def positions(self) -> List[Position]:
+        self._require_connected()
+        try:
+            raw = self._trade_client.get_positions(account=self._account)
+        except Exception as e:
+            raise RuntimeError(f"老虎证券持仓查询失败: {e}") from e
+
+        result = []
+        for p in (raw or []):
+            sym   = str(getattr(p, "contract", {}).symbol if hasattr(p, "contract") else getattr(p, "symbol", ""))
+            qty   = float(getattr(p, "quantity",         0))
+            avail = float(getattr(p, "available_qty",    qty))
+            cost  = float(getattr(p, "average_cost",     0))
+            price = float(getattr(p, "market_price",     0))
+            mv    = float(getattr(p, "position_value",   0))
+            pnl   = float(getattr(p, "unrealized_pnl",   0))
+            pnl_pct = float(getattr(p, "unrealized_pnl_ratio", 0)) * 100
+            currency = str(getattr(p, "currency", "USD"))
+            result.append(Position(
+                symbol=sym, name=sym,
+                quantity=qty, available_qty=avail,
+                cost_price=cost, current_price=price,
+                market_value=mv, pnl=pnl, pnl_pct=pnl_pct,
+                currency=currency, market="us",
+            ))
+        return result
+
+    def orders(self, status: str = "all", limit: int = 50) -> List[Order]:
+        self._require_connected()
+        try:
+            from tigeropen.common.consts import OrderStatus
+            raw = self._trade_client.get_orders(account=self._account, limit=limit)
+        except Exception as e:
+            raise RuntimeError(f"老虎证券订单查询失败: {e}") from e
+
+        result = []
+        for o in (raw or []):
+            side   = "buy" if str(getattr(o, "action", "")).upper() == "BUY" else "sell"
+            mapped = _tiger_order_status(str(getattr(o, "status", "")))
+            if status != "all" and mapped != status:
+                continue
+            contract = getattr(o, "contract", None)
+            sym = str(contract.symbol if contract else getattr(o, "symbol", ""))
+            result.append(Order(
+                order_id=str(getattr(o, "id", getattr(o, "order_id", ""))),
+                symbol=sym, name=sym,
+                side=side,
+                order_type=str(getattr(o, "order_type", "limit")).lower(),
+                quantity=float(getattr(o, "quantity", 0)),
+                filled_qty=float(getattr(o, "filled", 0)),
+                price=float(getattr(o, "limit_price", 0)),
+                avg_price=float(getattr(o, "avg_fill_price", 0)),
+                status=mapped,
+                created_at=str(getattr(o, "order_time", "")),
+                currency=str(getattr(o, "currency", "USD")),
+            ))
+        return result
+
+    def place_order(self, symbol: str, side: str, quantity: float,
+                    order_type: str = "limit", price: float = 0.0, **kwargs) -> OrderResult:
+        self._require_connected()
+        try:
+            from tigeropen.trade.domain.order import market_order, limit_order
+            from tigeropen.common.consts import Currency, Market
+
+            if order_type == "market":
+                order = market_order(
+                    account=self._account, symbol=symbol,
+                    action=side.upper(), quantity=int(quantity),
+                )
+            else:
+                order = limit_order(
+                    account=self._account, symbol=symbol,
+                    action=side.upper(), quantity=int(quantity), limit_price=price,
+                )
+            ret = self._trade_client.place_order(order)
+            return OrderResult(success=True, order_id=str(ret), broker_id=self.broker_id)
+        except Exception as e:
+            return OrderResult(success=False, message=str(e), broker_id=self.broker_id)
+
+    def cancel_order(self, order_id: str) -> bool:
+        self._require_connected()
+        try:
+            self._trade_client.cancel_order(account=self._account, id=int(order_id))
+            return True
+        except Exception:
+            return False
+
+    def _require_connected(self):
+        if not self._connected:
+            raise RuntimeError("老虎证券未连接，请先调用 connect()")
+
+
+def _tiger_order_status(raw: str) -> str:
+    raw = raw.upper()
+    if raw in ("FILLED",):
+        return "filled"
+    if raw in ("PARTIALLY_FILLED",):
+        return "partial"
+    if raw in ("CANCELLED", "EXPIRED", "REJECTED"):
+        return "cancelled"
+    return "open"