quantification-cn 1.0.0__tar.gz

quantification_cn-1.0.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: quantification-cn
+Version: 1.0.0
+Summary: quantification中国股市交易模块
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: akshare>=1.18.21
+Requires-Dist: pycryptodome>=3.23.0
+Requires-Dist: quantification>=1.0.0
+Requires-Dist: tushare>=1.4.24

quantification_cn-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[project]
+name = "quantification-cn"
+version = "1.0.0"
+description = "quantification中国股市交易模块"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "akshare>=1.18.21",
+    "pycryptodome>=3.23.0",
+    "quantification>=1.0.0",
+    "tushare>=1.4.24",
+]
+
+[dependency-groups]
+dev = [
+    "ipykernel>=7.1.0",
+    "scipy>=1.17.0",
+]
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages.find.where = ["."]
+packages.find.exclude = ["temp*", "ouput*"]
+
+[[tool.uv.index]]
+url = "https://pypi.tuna.tsinghua.edu.cn/simple"
+default = true

quantification_cn-1.0.0/quantification_cn/__init__.py

@@ -0,0 +1,7 @@
+from .data import *
+from .asset import *
+from .broker import *
+from .trader import *
+
+from .trigger import CnT
+from .benckmark import benchmark

quantification_cn-1.0.0/quantification_cn/asset/__init__.py

@@ -0,0 +1,4 @@
+from .etf import CnETF
+from .cash import RMB
+from .stock import CnStock
+from .exchange import CnExchange

quantification_cn-1.0.0/quantification_cn/asset/cash.py

@@ -0,0 +1,48 @@
+from datetime import date, time
+
+from quantification import Cash
+
+
+class RMB(Cash):
+    symbol = "RMB"
+
+    @classmethod
+    def class_name(cls) -> str:
+        return "人民币"
+
+    @property
+    def amount(self) -> float:
+        return self.value
+
+    @property
+    def extra(self) -> dict:
+        return {}
+
+    def available(self, *args, **kwargs) -> "RMB":
+        return self.copy
+
+    def liquidate(self, day: date, moment: time) -> float:
+        return self.value
+
+    @property
+    def copy(self) -> "RMB":
+        return self.__class__(self.value)
+
+    def __add__(self, other: "RMB") -> "RMB":
+        assert self == other, f"{type(other)}不为BaseCash[RMB]的实例，无法相加"
+
+        return self.__class__(self.value + other.value)
+
+    def __sub__(self, other: "RMB") -> "RMB":
+        assert self == other, f"{type(other)}不为BaseCash[RMB]的实例，无法相减"
+
+        return self.__class__(self.value - other.value)
+
+    def __eq__(self, other: "RMB") -> bool:
+        return isinstance(other, RMB)
+
+    def __init__(self, value: float):
+        self.value = value
+
+
+__all__ = ["RMB"]

quantification_cn-1.0.0/quantification_cn/asset/etf.py

@@ -0,0 +1,93 @@
+from typing import overload
+from datetime import date
+
+from quantification import ETF, Exchange
+
+from .exchange import CnExchange
+from ..utils import SharePosition, add_shares, sub_shares
+
+etf_family: dict[str, type["CnETF"]] = {}
+
+
+class CnETF(ETF):
+    """
+    T+1结算规则
+    """
+
+    @classmethod
+    def class_name(cls, *args, **kwargs) -> str:
+        return f"ETF{cls.code()}" if cls.symbol else "ETF"
+
+    @property
+    def amount(self) -> float:
+        return sum(self.share_position.values())
+
+    @property
+    def extra(self) -> dict:
+        return {"position": {k.isoformat(): int(v) for k, v in self.share_position.items()}}
+
+    def available(self, day: date) -> "CnETF":
+        return self.__class__[self.code()]({d: s for d, s in self.share_position.items() if d.date() < day})
+
+    @property
+    def copy(self) -> "CnETF":
+        return self.__class__[self.code()](self.share_position.copy())
+
+    def __add__(self, other: "CnETF") -> "CnETF":
+        assert self == other, f"只有同种ETF可以相加减, {self.__class__} != {other.__class__}"
+
+        return self.__class__[self.code()](add_shares(self.share_position, other.share_position))
+
+    def __sub__(self, other: "CnETF") -> "CnETF":
+        assert self == other, f"只有同种ETF可以相加减, {self.__class__} != {other.__class__}"
+
+        return self.__class__[self.code()](sub_shares(self.share_position, other.amount))
+
+    def __eq__(self, other: "CnETF") -> bool:
+        return isinstance(other, CnETF) and self.code() == other.code()
+
+    def __init__(self, share: SharePosition = None):
+        assert self.code() is not None, "未指定ETF代码, 无法实例化"
+        self.share_position = share or {}
+
+    @overload
+    def __class_getitem__(cls, symbol: str) -> "type[CnETF]":
+        ...
+
+    @overload
+    def __class_getitem__(cls, symbol_and_exchange: tuple[str, Exchange]) -> "type[CnETF]":
+        ...
+
+    def __class_getitem__(cls, arg: str | tuple[str, Exchange]) -> "type[CnETF]":
+        if isinstance(arg, str):
+            assert len(arg.split(".")) == 2, "格式: ETF['000001.SZ']"
+            symbol, exchange_str = arg.split(".")
+
+            exchange: Exchange | None = None
+            match exchange_str.upper():
+                case "SH":
+                    exchange = CnExchange.SSE
+                case "SZ":
+                    exchange = CnExchange.SZSE
+
+            if exchange is None:
+                raise ValueError(f"不支持的股票交易所后缀: {exchange_str}")
+
+            return cls[symbol, exchange]
+
+        symbol, exchange = arg
+
+        code = f"{symbol}.{exchange.code}"
+
+        if not etf_family.get(code):
+            # 动态创建新的股票类
+            etf_family[code] = type[CnETF](
+                f"ETF{symbol}",
+                (CnETF,),
+                {"symbol": symbol, "exchange": exchange},
+            )
+
+        return etf_family[code]
+
+
+__all__ = ["CnETF"]

quantification_cn-1.0.0/quantification_cn/asset/exchange.py

@@ -0,0 +1,10 @@
+from quantification import Exchange
+
+
+class CnExchange:
+    SSE = Exchange("上海证券交易所", "SSE", "SH")
+    SZSE = Exchange("深圳证券交易所", "SZSE", "SZ")
+    BSE = Exchange("北京证券交易所", "BSE", "BJ")
+
+
+__all__ = ["CnExchange"]

quantification_cn-1.0.0/quantification_cn/asset/stock.py

@@ -0,0 +1,97 @@
+from typing import overload
+from datetime import date
+
+from quantification import Stock, Exchange
+
+from .exchange import CnExchange
+from ..utils import SharePosition, add_shares, sub_shares
+
+stock_family: dict[str, type["CnStock"]] = {}
+
+
+class CnStock(Stock):
+    """
+    T+1结算规则
+    """
+
+    @classmethod
+    def class_name(cls, *args, **kwargs) -> str:
+        return f"股票{cls.code()}" if cls.symbol else "股票"
+
+    @property
+    def amount(self) -> float:
+        return sum(self.share_position.values())
+
+    @property
+    def extra(self) -> dict:
+        return {"position": {k.isoformat(): int(v) for k, v in self.share_position.items()}}
+
+    def available(self, day: date) -> "CnStock":
+        return self.__class__[self.code()]({d: s for d, s in self.share_position.items() if d.date() < day})
+
+    @property
+    def copy(self) -> "CnStock":
+        return self.__class__[self.code()](self.share_position.copy())
+
+    def __add__(self, other: "CnStock") -> "CnStock":
+        assert self == other, f"只有同种股票可以相加减, {self.__class__} != {other.__class__}"
+
+        return self.__class__[self.code()](add_shares(self.share_position, other.share_position))
+
+    def __sub__(self, other: "CnStock") -> "CnStock":
+        assert self == other, f"只有同种股票可以相加减, {self.__class__} != {other.__class__}"
+
+        return self.__class__[self.code()](sub_shares(self.share_position, other.amount))
+
+    def __eq__(self, other: "CnStock") -> bool:
+        return isinstance(other, CnStock) and self.code() == other.code()
+
+    def __init__(self, share: SharePosition = None):
+        assert self.code() is not None, "未指定股票代码, 无法实例化"
+        self.share_position = share or {}
+
+    @overload
+    def __class_getitem__(cls, symbol: str) -> "type[CnStock]":
+        """通过股票代码创建股票类，自动推断交易所"""
+        ...
+
+    @overload
+    def __class_getitem__(cls, symbol_and_exchange: tuple[str, Exchange]) -> "type[CnStock]":
+        """通过股票代码和交易所创建股票类"""
+        ...
+
+    def __class_getitem__(cls, arg: str | tuple[str, Exchange]) -> "type[CnStock]":
+        if isinstance(arg, str):
+            assert len(arg.split(".")) == 2, "格式: Stock['000001.SZ']"
+            symbol, exchange_str = arg.split(".")
+
+            exchange: Exchange | None = None
+            match exchange_str.upper():
+                case "SH":
+                    exchange = CnExchange.SSE
+                case "SZ":
+                    exchange = CnExchange.SZSE
+                case "BJ":
+                    exchange = CnExchange.BSE
+
+            if exchange is None:
+                raise ValueError(f"不支持的股票交易所后缀: {exchange_str}")
+
+            return cls[symbol, exchange]
+
+        symbol, exchange = arg
+
+        code = f"{symbol}.{exchange.code}"
+
+        if not stock_family.get(code):
+            # 动态创建新的股票类
+            stock_family[code] = type[CnStock](
+                f"Stock{symbol}",
+                (CnStock,),
+                {"symbol": symbol, "exchange": exchange},
+            )
+
+        return stock_family[code]
+
+
+__all__ = ["CnStock"]

quantification_cn-1.0.0/quantification_cn/benckmark.py

@@ -0,0 +1,18 @@
+from datetime import datetime, date
+
+from .data.api import CnDataAPI
+from .data.field import Field
+
+
+def benchmark(api: CnDataAPI, index_code: str, start: date, end: date) -> dict[datetime, float]:
+    res = api.query(
+        start_date=start,
+        end_date=end,
+        fields=[Field.IN_收盘点位],
+        index=index_code
+    )[Field.IN_收盘点位]
+
+    return {k.to_pydatetime(): v for k, v in res.items()}
+
+
+__all__ = ['benchmark']

quantification_cn-1.0.0/quantification_cn/broker/__init__.py

@@ -0,0 +1,2 @@
+from .etf import CnETFBroker
+from .stock import CnStockBroker

quantification_cn-1.0.0/quantification_cn/broker/etf.py

@@ -0,0 +1,204 @@
+from inspect import isclass
+from datetime import date, time, datetime
+
+from pandas import to_datetime
+
+from quantification import (
+    Field,
+    BaseBroker,
+    Portfolio,
+    Result,
+    logger
+)
+
+from ..asset import CnETF, RMB, CnExchange
+from ..trader import CnETFOrder
+
+
+class CnETFBroker(BaseBroker[CnETF, RMB]):
+    def matchable(self, asset: type[CnETF]) -> bool:
+        assert isclass(asset), "asset必须为class"
+
+        if not issubclass(asset, CnETF):
+            logger.trace(f"{self}: {asset}不是ETF, 无法处理, 交给下一个Broker")
+            return False
+
+        if not asset.exchange in [CnExchange.SSE, CnExchange.SZSE]:
+            logger.trace(f"{self}: {asset}不属于上交所|深交所, 无法处理, 交给下一个Broker")
+            return False
+
+        return True
+
+    def calculate_commission(self, trade_value: float, is_open: bool) -> float:
+        """计算佣金"""
+        if is_open:
+            commission_rate = self.open_commission
+        else:
+            commission_rate = self.close_commission
+
+        commission = trade_value * commission_rate
+        return max(commission, self.min_commission)
+
+    def calculate_transfer_fee(self, trade_value: float) -> float:
+        """计算过户费"""
+        return trade_value * self.transfer_fee_rate
+
+    def execute_order(self, order: CnETFOrder, portfolio: Portfolio) -> Result | None:
+        assert self.env is not None, f"{self}: 无法获取env"
+
+        # 根据交易时间确定使用的价格字段
+        field = None
+        match self.env.time:
+            case time(hour=9, minute=30):
+                field = Field.ETF_开盘价  # 开盘时使用开盘价
+            case time(hour=15, minute=0):
+                field = Field.ETF_收盘价  # 收盘时使用收盘价
+
+        if field is None:
+            raise ValueError(f"{self}: 只支持在9:30和15:00撮合交易")
+
+        # 查询股票价格数据
+        df = self.api.query(
+            self.start_date,
+            self.end_date,
+            [Field.ETF_开盘价, Field.ETF_收盘价],
+            etf=order.asset
+        )
+        try:
+            price = df.at[to_datetime(self.env.date), field]
+        except KeyError:
+            logger.warning(f"{self}: {order.asset}在 {self.env.date} {self.env.time} 无价格信息")
+            return None
+
+        logger.trace(f"{self}: 撮合交易{order}: 日期{self.env.date} 时间{self.env.time} 价格{price}")
+
+        match order.category:
+            case "buy":
+                # 买入交易处理
+                available_rmb = portfolio[RMB][0].amount
+                cost_factor = 1 + self.open_commission + self.transfer_fee_rate
+
+                # 计算实际交易股数
+                if order.share is not None:
+                    share = order.share  # 指定股数
+                elif order.value is not None:
+                    share = order.value / price / cost_factor  # 指定金额
+                else:
+                    share = available_rmb / price / cost_factor  # 全仓买入
+
+                share = int(share)
+
+                if share == 0:
+                    logger.warning(f"{self}: 购买股数为0, 跳过买入指令")
+                    return None
+
+                trade_value = price * share
+
+                # 计算手续费（ETF买入通常只有佣金，没有印花税，可能有过户费）
+                commission = self.calculate_commission(trade_value, is_open=True)
+                transfer_fee = self.calculate_transfer_fee(trade_value)
+
+                total_cost = trade_value + commission + transfer_fee
+
+                # 资金检查
+                if not self.allow_debt and total_cost > available_rmb:
+                    logger.warning(f"{self}: 可用RMB不足以购买{share}股({available_rmb}<{total_cost}), 跳过买入指令")
+                    return None
+
+                logger.success(
+                    f"{self}: 成功购买{share}股{order.asset}, "
+                    f"单价{price}, 交易金额{trade_value}, "
+                    f"佣金{commission}, 过户费{transfer_fee}, 总成本{total_cost}"
+                )
+
+                return Result(
+                    order=order,
+                    sold=[RMB(total_cost)],  # 支出总成本（包括手续费）
+                    brought=[order.asset({datetime.combine(self.env.date, self.env.time): share})],  # 获得ETF
+                )
+
+            case "sell":
+                # 卖出交易处理
+                if etfs := portfolio[order.asset]:
+                    available_share = etfs[0].available(self.env.date).amount
+                else:
+                    available_share = 0
+
+                # 计算实际交易股数
+                if order.share is not None:
+                    share = order.share  # 指定股数
+                elif order.value is not None:
+                    share = order.value / price  # 指定金额
+                else:
+                    share = available_share  # 全仓卖出
+
+                share = int(share)
+
+                # 做空检查
+                if not self.allow_short and share > available_share:
+                    logger.warning(f"{self}: 没有足够的股数卖出({available_share}>{order.share}), 跳过卖出指令")
+                    return None
+
+                trade_value = price * share
+
+                # 计算手续费（ETF卖出通常有佣金、印花税和过户费）
+                commission = self.calculate_commission(trade_value, is_open=False)
+                transfer_fee = self.calculate_transfer_fee(trade_value)
+                stamp_tax = trade_value * self.stamp_tax_rate
+
+                net_proceeds = trade_value - commission - transfer_fee - stamp_tax
+
+                # 确保净收入不为负数
+                net_proceeds = max(net_proceeds, 0)
+
+                logger.success(
+                    f"{self}: 成功出售{share}股{order.asset}, "
+                    f"单价{price}, 交易金额{trade_value}, "
+                    f"佣金{commission}, 过户费{transfer_fee}, 印花税{stamp_tax}, 净收入{net_proceeds}"
+                )
+
+                return Result(
+                    order=order,
+                    sold=[order.asset({datetime.combine(self.env.date, self.env.time): share})],  # 支出ETF
+                    brought=[RMB(net_proceeds)],  # 获得净现金（扣除手续费后）
+                )
+            case _:
+                raise ValueError(f"{self}: 无效的订单类型: {order.category}")
+
+    def liquidate_asset(self, asset: CnETF, day: date, moment: time) -> RMB:
+        df = self.api.query(
+            self.start_date,
+            self.end_date,
+            [Field.ETF_收盘价],
+            etf=asset.__class__,
+            no_mask=True,
+        )
+
+        close_price = df.iloc[df.index.searchsorted(to_datetime(day), side="left")][Field.ETF_收盘价]
+
+        return RMB(close_price * asset.amount)
+
+    def __init__(
+            self,
+            allow_debt: bool = False,
+            allow_short: bool = False,
+            open_commission: float = 0.0003,  # 开仓佣金比例，默认万分之三
+            close_commission: float = 0.0003,  # 平仓佣金比例，默认万分之三
+            min_commission: float = 0.1,  # 最低佣金，默认0.1元（部分券商ETF交易无最低佣金或更低）
+            stamp_tax_rate: float = 0.001,  # 印花税率，默认千分之一（卖出时收取）
+            transfer_fee_rate: float = 0.00002  # 过户费率，默认十万分之二（双边收取）
+    ):
+        super().__init__()
+
+        self.allow_debt = allow_debt  # 允许负头寸（融资）
+        self.allow_short = allow_short  # 允许做空（融券）
+
+        # ETF交易费率参数（与股票有所不同）
+        self.open_commission = open_commission  # 开仓佣金比例
+        self.close_commission = close_commission  # 平仓佣金比例
+        self.min_commission = min_commission  # 最低佣金金额
+        self.stamp_tax_rate = stamp_tax_rate  # 印花税率（仅卖出时收取）
+        self.transfer_fee_rate = transfer_fee_rate  # 过户费率（双边收取）
+
+
+__all__ = ["CnETFBroker"]