quantification 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

quantification/api/tushare/delegate/income.py

@@ -0,0 +1,34 @@
+import tushare as ts
+
+from quantification.core import (
+    Field,
+    Config,
+    cache_query
+)
+
+from .common import TushareSheetDelegate
+from ..setting import TuShareSetting
+
+
+class IncomeDelegate(TushareSheetDelegate):
+    pair = [
+        (Field.IS_营业总收入, "total_revenue"),
+        (Field.IS_营业总成本, "total_cogs"),
+        (Field.IS_营业利润, "operate_profit"),
+        (Field.IS_利润总额, "total_profit"),
+        (Field.IS_息税前利润, "ebit"),
+        (Field.IS_息税折旧摊销前利润, "ebitda"),
+        (Field.IS_所得税费用, "income_tax"),
+        (Field.IS_净利润, "n_income"),
+        (Field.IS_归母净利润, "n_income_attr_p"),
+        (Field.IS_综合收益, "t_compr_income"),
+        (Field.IS_归母综合收益, "compr_inc_attr_p"),
+        (Field.IS_销售费用, "sell_exp"),
+        (Field.IS_管理费用, "admin_exp"),
+        (Field.IS_财务费用, "fin_exp"),
+        (Field.IS_研发费用, "rd_exp"),
+    ]
+
+    def __init__(self, config: Config, setting: TuShareSetting):
+        super().__init__(config, setting)
+        self.api = cache_query()(ts.pro_api(setting.tushare_token).income)

quantification/api/tushare/delegate/index_daily.py

@@ -0,0 +1,61 @@
+from datetime import date, datetime, time
+
+import pandas as pd
+import tushare as ts
+
+from quantification.core import (
+    Field,
+    Config,
+    cache_query,
+    BaseDelegate,
+)
+
+from ..setting import TuShareSetting
+
+
+class IndexDailyDelegate(BaseDelegate[TuShareSetting]):
+    pair = [
+        (Field.IN_开盘点位, "open"),
+        (Field.IN_收盘点位, "close"),
+        (Field.IN_最高点位, "high"),
+        (Field.IN_最低点位, "low")
+    ]
+
+    def has_field(self, field: Field, **kwargs):
+        if self.field2str.get(field) is None:
+            return False
+
+        index = kwargs.get("index")
+        assert index is not None, "请传入index='xxx'"
+        assert type(index) == str, f"index必须为字符串, 实际为{type(index)}"
+
+        return True
+
+    def query(self, start_date: date, end_date: date, fields: list[Field], **kwargs) -> pd.DataFrame:
+        data = self.api(
+            ts_code=kwargs.get("index"),
+            start_date=start_date.strftime("%Y%m%d"),
+            end_date=end_date.strftime("%Y%m%d"),
+        )
+
+        data = self.rename_columns(data, "trade_date")
+        data = self.use_date_index(data)
+
+        return data
+
+    def mask(self, data: pd.DataFrame, start_date: date, end_date: date, fields: list[Field], **kwargs) -> pd.DataFrame:
+        mask = pd.DataFrame(index=data.index, columns=data.columns)
+        index = pd.Series(mask.index)
+
+        for field in fields:
+            match field:
+                case Field.IN_开盘点位:
+                    mask[field] = list(map(lambda x: datetime.combine(x, time(9, 30, 0)), index))
+                case Field.IN_收盘点位 | Field.IN_最高点位 | Field.IN_最低点位:
+                    mask[field] = list(map(lambda x: datetime.combine(x, time(17, 0, 0)), index))
+
+        return mask
+
+    def __init__(self, config: Config, setting: TuShareSetting):
+        super().__init__(config, setting)
+        self.api = cache_query()(ts.pro_api(setting.tushare_token).index_daily)

quantification/api/tushare/delegate/pro_bar.py

@@ -0,0 +1,80 @@
+from datetime import date, datetime, time
+
+import pandas as pd
+import tushare as ts
+
+from quantification.core import (
+    Field,
+    Stock,
+    cache_query,
+    BaseDelegate,
+    StockExchange as E
+)
+
+from ..setting import TuShareSetting
+
+api = cache_query()(ts.pro_bar)
+
+
+class ProBarDelegate(BaseDelegate[TuShareSetting]):
+    pair = [
+        (Field.ST_昨收价, "pre_close"),
+        (Field.ST_开盘价, "open"),
+        (Field.ST_最高价, "high"),
+        (Field.ST_最低价, "low"),
+        (Field.ST_收盘价, "close"),
+        (Field.ST_涨跌额, "change"),
+        (Field.ST_涨跌幅, "pct_chg"),
+        (Field.ST_成交量, "vol"),
+        (Field.ST_成交额, "amount")
+    ]
+
+    def has_field(self, field: Field, **kwargs):
+        if self.field2str.get(field) is None:
+            return False
+
+        stock = kwargs.get("stock")
+        assert stock is not None, "请传入stock参数, 如stock=Stock['000001']"
+        assert issubclass(stock, Stock), f"stock参数必须为Stock子类, 实际为{type(stock)}"
+
+        if stock.exchange not in [E.SZSE, E.BSE, E.SSE]:
+            return False
+
+        return True
+
+    def query(self, start_date: date, end_date: date, fields: list[Field], **kwargs) -> pd.DataFrame:
+        stock: Stock = kwargs.get("stock")
+        exchange = {
+            E.SSE: "SH",
+            E.SZSE: "SZ",
+            E.BSE: "BJ"
+        }[stock.exchange]
+
+        data = api(
+            ts_code=f"{stock.symbol}.{exchange}",
+            start_date=start_date.strftime("%Y%m%d"),
+            end_date=end_date.strftime("%Y%m%d"),
+            adj=self.config.adjust
+        )
+
+        data = self.rename_columns(data, "trade_date")
+        data = self.use_date_index(data)
+
+        data[Field.ST_成交额] = data[Field.ST_成交额].apply(lambda x: x / 10)
+
+        return data
+
+    def mask(self, data: pd.DataFrame, start_date: date, end_date: date, fields: list[Field], **kwargs) -> pd.DataFrame:
+        mask = pd.DataFrame(index=data.index, columns=data.columns)
+        index = pd.Series(mask.index)
+
+        for field in fields:
+            match field:
+                case Field.ST_昨收价:
+                    mask[field] = list(map(lambda x: datetime.combine(x, time(0, 0, 0)), index))
+                case Field.ST_开盘价:
+                    mask[field] = list(map(lambda x: datetime.combine(x, time(9, 30, 0)), index))
+                case Field.ST_最高价 | Field.ST_最低价 | Field.ST_收盘价 | Field.ST_涨跌额 | Field.ST_涨跌幅 | Field.ST_成交量 | Field.ST_成交额:
+                    mask[field] = list(map(lambda x: datetime.combine(x, time(17, 0, 0)), index))
+
+        return mask

quantification/api/tushare/setting.py

@@ -0,0 +1,5 @@
+from pydantic import Field, BaseModel
+
+
+class TuShareSetting(BaseModel):
+    tushare_token: str = Field(description='TuShare接口Token')

quantification/api/tushare/tushare.py

@@ -0,0 +1,17 @@
+from quantification.core.data import BaseAPI
+
+from .setting import TuShareSetting
+from .delegate import *
+
+
+class TuShareAPI(BaseAPI[TuShareSetting]):
+    setting_class = TuShareSetting
+    delegate_classes = [
+        ProBarDelegate,
+        IncomeDelegate,
+        CashflowDelegate,
+        IndexDailyDelegate,
+        DailyBasicDelegate,
+        BalanceSheetDelegate,
+        FinanceIndicatorDelegate,
+    ]

quantification/core/__init__.py

@@ -0,0 +1,9 @@
+from .data import *
+from .asset import *
+from .trader import *
+from .strategy import *
+
+from .util import inject
+from .cache import cache_query
+from .logger import logger
+from .configure import Config, config

quantification/core/asset/__init__.py

@@ -0,0 +1,6 @@
+from .base_asset import BaseAsset
+from .base_broker import BaseBroker
+
+from .cash import Cash, RMB, HKD, USD
+from .stock import Stock, StockExchange
+from .broker import StockBrokerCN

quantification/core/asset/base_asset.py

@@ -0,0 +1,96 @@
+from abc import ABCMeta, abstractmethod
+
+from ..env import EnvGetter
+
+
+class BaseAssetMeta(ABCMeta):
+    def __repr__(self: "BaseAsset"):
+        return self.name()
+
+    __str__ = __repr__
+
+
+class BaseAsset(EnvGetter, metaclass=BaseAssetMeta):
+    is_closeable = True  # 若为True, 当empty时将从Portfolio中移除该资产
+
+    @classmethod
+    @abstractmethod
+    def type(cls):
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def name(cls) -> str:
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def amount(self, *args, **kwargs) -> int:
+        """
+        资产数额
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def extra(self, *args, **kwargs) -> dict:
+        """
+        资产额外信息
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def is_empty(self) -> bool:
+        """
+        若为True, 则会在Portfolio中移除该资产
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def available(self, *args, **kwargs):
+        """
+        获取该资产可用于出售的部分
+        """
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def copy(self, *args, **kwargs):
+        """
+        复制资产对象
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __add__(self, other: "BaseAsset"):
+        """
+        购买同一种资产
+        :param other: 同一种资产
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __sub__(self, other: "BaseAsset"):
+        """
+        出售该资产的一部分
+        :param other: 同一种资产
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __eq__(self, other: "BaseAsset"):
+        """
+        判断是否为同一种资产
+        :param other: 任意资产
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def __repr__(self):
+        raise NotImplementedError
+
+    __str__ = __repr__
+
+
+__all__ = ["BaseAsset"]

quantification/core/asset/base_broker.py

@@ -0,0 +1,42 @@
+from abc import ABC, abstractmethod
+from typing import TypeVar, Generic, TYPE_CHECKING
+from datetime import date
+
+from ..env import EnvGetter
+
+if TYPE_CHECKING:
+    from .base_asset import BaseAsset
+    from ..data import BaseAPI
+    from ..trader import BaseOrder, BaseStage, Result
+
+AssetType = TypeVar('AssetType', bound="BaseAsset")
+
+
+class BaseBroker(Generic[AssetType], ABC, EnvGetter):
+    def __init__(self, api: "BaseAPI", start_date: date, end_date: date, stage: type["BaseStage"]):
+        super().__init__()
+
+        self.api = api
+        self.start_date = start_date
+        self.end_date = end_date
+        self.stage = stage
+
+    @abstractmethod
+    def matchable(self, asset: "BaseAsset") -> bool:
+        raise NotImplementedError
+
+    @abstractmethod
+    def execute_order(self, order: "BaseOrder[AssetType]") -> "Result":
+        raise NotImplementedError
+
+    @abstractmethod
+    def liquidate_asset(self, asset: "BaseAsset", day: date, stage: "BaseStage") -> int:
+        raise NotImplementedError
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}>"
+
+    __str__ = __repr__
+
+
+__all__ = ['BaseBroker']

quantification/core/asset/broker.py

@@ -0,0 +1,108 @@
+from typing import TYPE_CHECKING
+from datetime import timedelta, date, time
+
+from pandas import to_datetime
+
+from .cash import RMB
+from .stock import Stock
+from .stock import StockExchange as E
+from .base_broker import BaseBroker
+
+from ..logger import logger
+from ..data.field import Field
+from ..data.base_api import BaseAPI
+from ..trader.order import StockOrder
+from ..trader.base_order import Result
+from ..trader.base_stage import BaseStage
+
+if TYPE_CHECKING:
+    from .base_asset import BaseAsset
+
+
+class StockBrokerCN(BaseBroker[Stock]):
+    def matchable(self, asset: "BaseAsset") -> bool:
+        if not isinstance(asset, Stock):
+            logger.trace(f"{asset}不是股票, {self}无法处理, 交给下一个Broker")
+            return False
+
+        if not asset.exchange in [E.SSE, E.SZSE, E.BSE]:
+            logger.trace(f"{asset}不属于上交所|深交所|北交所, {self}无法处理, 交给下一个Broker")
+            return False
+
+        return True
+
+    def execute_order(self, order: StockOrder) -> Result:
+        assert self.env is not None, "无法获取env"
+
+        match self.env.time:
+            case time(hour=9, minute=30, second=0):
+                field = Field.ST_开盘价
+            case time(hour=15, minute=0, second=0):
+                field = Field.ST_收盘价
+            case _:
+                raise ValueError("StockBrokerCN只支持在9:30和15:00撮合交易")
+
+        df = self.api.query(
+            self.start_date,
+            self.end_date,
+            [Field.ST_开盘价, Field.ST_收盘价],
+            stock=Stock[order.asset.symbol]
+        )
+
+        price = df.at[to_datetime(self.env.date), field]
+
+        logger.trace(f"{self}撮合交易{order}: 日期{self.env.date} 时间{self.env.time} 价格{price}")
+
+        match order.category:
+            case "buy":
+                return Result(
+                    order=order,
+                    sold=[RMB(price * order.asset.amount)],
+                    brought=[order.asset],
+                )
+            case "sell":
+                return Result(
+                    order=order,
+                    sold=[order.asset],
+                    brought=[RMB(price * order.asset.amount)],
+                )
+            case _:
+                raise ValueError(f"invalid order category: {order.category}")
+
+    def liquidate_asset(self, asset: Stock, day: date, stage: BaseStage) -> RMB:
+        df = self.api.query(
+            self.start_date,
+            self.end_date,
+            [Field.ST_开盘价, Field.ST_收盘价],
+            stock=Stock[asset.symbol]
+        )
+
+        liquidating_value = 0
+
+        if not to_datetime(day) in df.index:
+            for brought_day, brought_share in asset.share_position.items():
+                nearest_day = df.index[df.index.searchsorted(to_datetime(day), side='left')]
+                liquidating_value += df.at[nearest_day, Field.ST_开盘价] * brought_share
+        else:
+            for brought_day, brought_share in asset.share_position.items():
+                if brought_day < day and stage.time <= time(9, 30):
+                    liquidating_value += df.at[to_datetime(day), Field.ST_开盘价] * brought_share
+
+                elif brought_day < day and stage.time <= time(15, 0):
+                    liquidating_value += df.at[to_datetime(day), Field.ST_收盘价] * brought_share
+
+                elif (brought_day < day and stage.time >= time(15, 0)) or brought_day == day:
+                    pos = df.index.get_loc(to_datetime(day))  # 获取位置
+                    next_day = df.index[pos + 1]  # 下一个位置的日期
+                    liquidating_value += df.at[next_day, Field.ST_开盘价] * brought_share
+
+                else:
+                    raise ValueError(f"invalid brought day: {brought_day}")
+
+        return liquidating_value
+
+    def __init__(self, api: "BaseAPI", start_date: date, end_date: date, stage: type[BaseStage]):
+        super().__init__(api, start_date - timedelta(days=10), end_date + timedelta(days=10), stage)
+
+
+__all__ = ["StockBrokerCN"]

quantification/core/asset/cash.py

@@ -0,0 +1,75 @@
+from .base_asset import BaseAsset
+
+cash_family: dict[str:type["Cash"]] = {}
+
+
+class Cash(BaseAsset):
+    symbol: str = None
+    is_closeable = False
+
+    @classmethod
+    def type(cls, *args, **kwargs):
+        return "Cash"
+
+    @classmethod
+    def name(cls, *args, **kwargs):
+        return f"现金{cls.symbol}" if cls.symbol else "全部现金"
+
+    @property
+    def amount(self, *args, **kwargs):
+        return self.value
+
+    @property
+    def extra(self, *args, **kwargs):
+        return {}
+
+    @property
+    def is_empty(self):
+        return self.value == 0
+
+    @property
+    def copy(self):
+        return Cash[self.symbol](self.value)
+
+    def available(self, *args, **kwargs):
+        return Cash[self.symbol](self.value)
+
+    def __add__(self, other: "Cash"):
+        assert self == other, f"只能和Cash相加, 实际类型{type(other)}"
+
+        return Cash[self.symbol](self.value + other.value)
+
+    def __sub__(self, other: "Cash"):
+        assert self == other, f"只能和Cash相减, 实际类型{type(other)}"
+
+        return Cash[self.symbol](self.value - other.value)
+
+    def __eq__(self, other: "Cash"):
+        return isinstance(other, Cash) and self.symbol == other.symbol
+
+    def __repr__(self):
+        return f"{self.name()}({self.value}元)"
+
+    __str__ = __repr__
+
+    def __init__(self, value: float = 0):
+        assert self.symbol is not None, "未指定现金类型, 无法实例化"
+        assert value >= 0, f"现金金额不能为负, 实际为{value}"
+        self.value = value
+
+    def __class_getitem__(cls, symbol: str):
+        if not cash_family.get(symbol):
+            cash_family[symbol] = type(
+                f"Cash{symbol}",
+                (Cash,),
+                {"symbol": symbol},
+            )
+
+        return cash_family[symbol]
+
+
+RMB = Cash["RMB"]
+HKD = Cash["HKD"]
+USD = Cash["USD"]
+
+__all__ = ["Cash", "RMB", "HKD", "USD"]