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

quantification/core/data/field.py

@@ -0,0 +1,213 @@
+from enum import Enum, auto
+
+
+class Field(Enum):
+    """
+    ----------------------------------------------------------------
+    股票 ST
+    ----------------------------------------------------------------
+    """
+    ST_开盘价 = auto()
+    ST_最高价 = auto()
+    ST_最低价 = auto()
+    ST_收盘价 = auto()
+    ST_昨收价 = auto()  # 后复权
+    ST_涨跌额 = auto()
+    ST_涨跌幅 = auto()  # 后复权
+    ST_成交量 = auto()
+    ST_成交额 = auto()  # 万元
+    ST_振幅 = auto()
+    ST_换手率 = auto()
+    ST_自由流通股换手率 = auto()
+    ST_量比 = auto()
+    ST_总市值 = auto()
+    ST_流通市值 = auto()
+
+    """
+    ----------------------------------------------------------------
+    利润表 IS
+    ----------------------------------------------------------------
+    """
+    IS_营业总收入 = auto()
+    IS_营业总成本 = auto()
+    IS_营业利润 = auto()
+    IS_利润总额 = auto()
+    IS_息税前利润 = auto()
+    IS_息税折旧摊销前利润 = auto()
+    IS_所得税费用 = auto()
+    IS_净利润 = auto()
+    IS_归母净利润 = auto()
+    IS_综合收益 = auto()
+    IS_归母综合收益 = auto()
+
+    IS_销售费用 = auto()
+    IS_管理费用 = auto()
+    IS_财务费用 = auto()
+    IS_研发费用 = auto()
+
+    """
+    ----------------------------------------------------------------
+    资产负债表 BS
+    ----------------------------------------------------------------
+    """
+    BS_总股本 = auto()
+    BS_库存股 = auto()
+    BS_资本公积 = auto()
+    BS_盈余公积 = auto()
+    BS_未分配利润 = auto()
+    BS_股东权益合计 = auto()
+    BS_归母股东权益合计 = auto()
+
+    BS_货币资金 = auto()
+    BS_交易性金融资产 = auto()
+    BS_应收票据 = auto()
+    BS_应收账款 = auto()
+    BS_应收股利 = auto()
+    BS_应收利息 = auto()
+    BS_其他应收款 = auto()
+    BS_预付款项 = auto()
+    BS_存货 = auto()
+    BS_一年内到期的非流动资产 = auto()
+    BS_可供出售金融资产 = auto()
+    BS_持有至到期投资 = auto()
+    BS_长期股权投资 = auto()
+    BS_投资性房地产 = auto()
+    BS_定期存款 = auto()
+    BS_长期应收款 = auto()
+    BS_固定资产 = auto()
+    BS_在建工程 = auto()
+    BS_无形资产 = auto()
+    BS_研发支出 = auto()
+    BS_商誉 = auto()
+    BS_流动资产合计 = auto()
+    BS_非流动资产合计 = auto()
+    BS_资产合计 = auto()
+
+    BS_短期借款 = auto()
+    BS_长期借款 = auto()
+    BS_交易性金融负债 = auto()
+    BS_应付票据 = auto()
+    BS_应付账款 = auto()
+    BS_应付职工薪酬 = auto()
+    BS_应付利息 = auto()
+    BS_应付股利 = auto()
+    BS_应付短期债券 = auto()
+    BS_应付债券 = auto()
+    BS_长期应付款 = auto()
+    BS_预收款项 = auto()
+    BS_一年内到期的非流动负债 = auto()
+    BS_流动负债合计 = auto()
+    BS_非流动负债合计 = auto()
+    BS_负债合计 = auto()
+
+    """
+    ----------------------------------------------------------------
+    现金流量表 CS
+    ----------------------------------------------------------------
+    """
+    CS_经营活动现金流入 = auto()
+    CS_经营活动现金流出 = auto()
+    CS_经营活动净现金流 = auto()
+
+    CS_投资活动现金流入 = auto()
+    CS_投资活动现金流出 = auto()
+    CS_投资活动净现金流 = auto()
+
+    CS_筹资活动现金流入 = auto()
+    CS_筹资活动现金流出 = auto()
+    CS_筹资活动净现金流 = auto()
+
+    CS_现金及现金等价物净增加额 = auto()
+
+    """
+    ----------------------------------------------------------------
+    财务指标 FI
+    ----------------------------------------------------------------
+    """
+
+    FI_净资产收益率 = auto()
+
+    """
+    ----------------------------------------------------------------
+    指数 IN
+    ----------------------------------------------------------------
+    """
+    IN_开盘点位 = auto()
+    IN_收盘点位 = auto()
+    IN_最高点位 = auto()
+    IN_最低点位 = auto()
+
+    """
+    ----------------------------------------------------------------
+    杠杆率 LEV
+    ----------------------------------------------------------------
+    """
+    LEV_居民部门 = auto()  # 注意单位: %
+    LEV_非金融企业部门 = auto()  # 注意单位: %
+    LEV_政府部门 = auto()  # 注意单位: %
+    LEV_中央政府 = auto()  # 注意单位: %
+    LEV_地方政府 = auto()  # 注意单位: %
+    LEV_实体经济部门 = auto()  # 注意单位: %
+    LEV_金融部门资产方 = auto()  # 注意单位: %
+    LEV_金融部门负债方 = auto()  # 注意单位: %
+
+    """
+    ----------------------------------------------------------------
+    企业商品交易价格指数 CGPI
+    ----------------------------------------------------------------
+    """
+    CGPI_总指数 = auto()
+    CGPI_总指数同比增长 = auto()  # 注意单位: %
+    CGPI_总指数环比增长 = auto()  # 注意单位: %
+    CGPI_农产品 = auto()
+    CGPI_农产品同比增长 = auto()  # 注意单位: %
+    CGPI_农产品环比增长 = auto()  # 注意单位: %
+    CGPI_矿产品 = auto()
+    CGPI_矿产品同比增长 = auto()  # 注意单位: %
+    CGPI_矿产品环比增长 = auto()  # 注意单位: %
+    CGPI_煤油电 = auto()
+    CGPI_煤油电同比增长 = auto()  # 注意单位: %
+    CGPI_煤油电环比增长 = auto()  # 注意单位: %
+
+    """
+    ----------------------------------------------------------------
+    国际直接投资 FDI
+    ----------------------------------------------------------------
+    """
+    FDI_当月 = auto()  # 注意单位: 万美元
+    FDI_当月同比增长 = auto()  # 注意单位: %
+    FDI_当月环比增长 = auto()  # 注意单位: %
+    FDI_累计 = auto()  # 注意单位: 万美元
+    FDI_累计同比增长 = auto()  # 注意单位: %
+
+    """
+    ----------------------------------------------------------------
+    利率 RATE
+    ----------------------------------------------------------------
+    """
+    RATE_LPR1年 = auto()  # 注意单位: %
+    RATE_LPR5年 = auto()  # 注意单位: %
+    RATE_短期贷款 = auto()  # 注意单位: %
+    RATE_中长期贷款 = auto()  # 注意单位: %
+
+    """
+    ----------------------------------------------------------------
+    社会融资规模 AFRE
+    ----------------------------------------------------------------
+    """
+    AFRE_总增量 = auto()  # 注意单位: 亿元
+    AFRE_人民币贷款增量 = auto()  # 注意单位: 亿元
+    AFRE_委托贷款外币贷款增量 = auto()  # 注意单位: 折合人民币, 亿元
+    AFRE_委托贷款增量 = auto()  # 注意单位: 亿元
+    AFRE_信托贷款增量 = auto()  # 注意单位: 亿元
+    AFRE_未贴现银行承兑汇票增量 = auto()  # 注意单位: 亿元
+    AFRE_企业债券增量 = auto()  # 注意单位: 亿元
+    AFRE_非金融企业境内股票融资增量 = auto()  # 注意单位: 亿元
+
+    def __repr__(self):
+        return self.name
+
+    __str__ = __repr__
+
+
+__all__ = ["Field"]

quantification/core/data/panel.py

@@ -0,0 +1,42 @@
+from datetime import datetime
+
+import pandas as pd
+
+from .field import Field
+
+
+class DataPanel(pd.DataFrame):
+    def __init__(self, data: pd.DataFrame = None, mask: pd.DataFrame = None):
+        data = data if data is not None else pd.DataFrame()
+        mask = mask if mask is not None else pd.DataFrame()
+        self.mask = mask
+        super().__init__(data)
+
+        if self.shape[0] != 0:
+            assert type(self.index) == pd.DatetimeIndex, \
+                f"DataPanel data的索引必须为pd.DatetimeIndex, 实际为{type(self.index)}"
+
+        for col in self.columns:
+            assert type(col) == Field, \
+                f"DataPanel data的列必须为core.Field, {col}实际为{type(col)}"
+
+        if self.mask.shape[0] != 0:
+            assert type(self.index) == pd.DatetimeIndex, \
+                f"DataPanel mask的索引必须为pd.DatetimeIndex, 实际为{type(self.index)}"
+
+        for col in self.columns:
+            assert type(col) == Field, \
+                f"DataPanel mask的列必须为core.Field, {col}实际为{type(col)}"
+
+        assert self.columns.equals(self.mask.columns) and self.shape == self.mask.shape, \
+            f"DataPanel data与mask的结构不一致, data:\n{self}\nmask:\n{self.mask} "
+
+    def __lshift__(self, other: "DataPanel"):
+        assert isinstance(other, DataPanel), f"DataPanel只能与DataPanel进行lshift操作, 实际为{type(other)}"
+        return DataPanel(self.join(other, how='outer'), self.mask.join(other.mask, how='outer'))
+
+    def on(self, d: datetime) -> pd.DataFrame:
+        return self.where((self.mask <= d) | self.isna(), other="invalid")[:d.date()]
+
+
+__all__ = ["DataPanel"]

quantification/core/env.py

@@ -0,0 +1,25 @@
+import datetime
+from abc import ABCMeta
+from dataclasses import dataclass
+
+from typing import Callable
+
+
+@dataclass
+class Env:
+    date: datetime.date
+    time: datetime.time
+
+
+class EnvGetter(metaclass=ABCMeta):
+    getter: Callable[[], Env] | None = None
+
+    @property
+    def env(self) -> Env | None:
+        if self.__class__.getter is not None:
+            return self.__class__.getter()
+
+        return None
+
+
+__all__ = ['EnvGetter', "Env"]

quantification/core/logger.py

@@ -0,0 +1,94 @@
+import sys
+from datetime import datetime
+
+from loguru import logger as _logger
+from pydantic import BaseModel
+from loguru._datetime import datetime as _datetime
+
+from .env import EnvGetter
+from .configure import config
+
+
+class Record(BaseModel):
+    file: str
+    func: str
+    line: int
+    level: str
+    message: str
+
+
+class Logger(EnvGetter):
+    def __init__(self):
+        super().__init__()
+
+        _logger.remove()
+        _logger.add(
+            sink=self.sink,
+            colorize=True,  # 在支持颜色的终端显示彩色日志
+            backtrace=True,  # 记录异常堆栈
+            diagnose=True,  # 显示变量值
+            level=config.log_level,
+            format=(
+                "<g>{time:YYYY-MM-DD HH:mm:ss}</g> "
+                "[<lvl>{level:^7}</lvl>] "
+                "|函数 <r><u>{function}</u></r>: <c>{line}</c>行| "
+                "{message}"
+            ),
+        )
+
+        self.records: dict[str, list[Record]] = {}
+
+    def sink(self, message):
+        if not self.env:
+            return
+
+        sys.stdout.write(message)
+        sys.stdout.flush()
+
+        datetime_str = message.record["time"].isoformat()
+        if datetime_str not in self.records:
+            self.records[datetime_str] = []
+
+        self.records[datetime_str].append(Record(
+            file=message.record["file"].name,
+            func=message.record["function"],
+            line=message.record["line"],
+            level=message.record["level"].name,
+            message=message.record["message"]
+        ))
+
+    def hijack(self):
+        if env := self.env:
+            current = datetime.combine(env.date, env.time)
+        else:
+            current = datetime.now()
+        return _logger.opt(depth=1).patch(lambda r: r.update(time=_datetime(
+            year=current.year,
+            month=current.month,
+            day=current.day,
+            hour=current.hour,
+            minute=current.minute,
+        )))
+
+    def trace(self, msg):
+        self.hijack().trace(msg)
+
+    def debug(self, msg):
+        self.hijack().debug(msg)
+
+    def success(self, msg):
+        self.hijack().success(msg)
+
+    def info(self, msg):
+        self.hijack().info(msg)
+
+    def warning(self, msg):
+        self.hijack().warning(msg)
+
+    def error(self, msg):
+        self.hijack().error(msg)
+
+
+logger = Logger()
+
+__all__ = ["logger", "Record"]

quantification/core/strategy/__init__.py

@@ -0,0 +1,3 @@
+from .base_use import Use, Injection, WrappedFunc, Func
+from .base_trigger import Trigger, Condition
+from .base_strategy import BaseStrategy

quantification/core/strategy/base_strategy.py

@@ -0,0 +1,66 @@
+from typing import Any
+
+from .base_use import WrappedFunc, Func
+from .base_trigger import Trigger
+
+
+class Hook:
+    def __init__(
+            self,
+            func: WrappedFunc,
+            *,
+            once: bool = False,
+    ):
+        self.func = func
+        self.once = once
+        self.triggered = False
+
+    @property
+    def active(self) -> bool:
+        if self.once:
+            return not self.triggered
+
+        return True
+
+    def __call__(self, **kwargs):
+        self.triggered = True
+        return self.func(**kwargs)
+
+    def __repr__(self) -> str:
+        return f"<Hook {self.func}>"
+
+    __str__ = __repr__
+
+
+class BaseStrategy:
+    def __init__(self):
+        self.context: dict[str, Any] = {}
+        self.hooks: dict[Trigger, list[Hook]] = {}
+
+    def on(self, trigger: Trigger, *, once: bool = False):
+        def wrapper(func: Func | WrappedFunc) -> WrappedFunc:
+            wrapped_func = func if isinstance(func, WrappedFunc) else WrappedFunc(func)
+
+            if not self.hooks.get(trigger):
+                self.hooks[trigger] = []
+
+            self.hooks[trigger].append(Hook(wrapped_func, once=once))
+
+            return wrapped_func
+
+        return wrapper
+
+    def triggered(self, **kwargs) -> list[Hook]:
+        triggered_hooks: list[Hook] = []
+        for trigger, hooks in self.hooks.items():
+            if not trigger.fulfilled(**kwargs):
+                continue
+
+            for hook in hooks:
+                if hook.active:
+                    triggered_hooks.append(hook)
+
+        return triggered_hooks
+
+
+__all__ = ["BaseStrategy"]

quantification/core/strategy/base_trigger.py

@@ -0,0 +1,69 @@
+from abc import ABC, abstractmethod
+
+from ..util import inject
+
+
+class Condition(ABC):
+    @abstractmethod
+    def __call__(self, **kwargs):
+        raise NotImplementedError
+
+    @abstractmethod
+    def name(self) -> str:
+        raise NotImplementedError
+
+    def settle(self, **kwargs):
+        ...
+
+    def __repr__(self):
+        return f"Condition({self.name()})"
+
+    __str__ = __repr__
+
+
+class Trigger:
+    def __init__(self, *conditions: Condition):
+        self.conditions = conditions
+
+    def fulfilled(self, **kwargs) -> bool:
+        is_fulfilled = all([inject(condition, **kwargs) for condition in self.conditions])
+
+        if not is_fulfilled:
+            return False
+
+        for condition in self.conditions:
+            inject(condition.settle, **kwargs)
+
+        return True
+
+    def __and__(self, other):
+        if other is None:
+            return self
+
+        if isinstance(other, Trigger):
+            return Trigger(*self.conditions, *other.conditions)
+
+        raise NotImplementedError(f"不支持合并条件{other}")
+
+    def __rand__(self, other):
+        if other is None:
+            return self
+
+        if isinstance(other, Trigger):
+            return Trigger(*other.conditions, *self.conditions)
+
+        raise NotImplementedError(f"不支持合并条件{other}")
+
+    def __or__(self, other):
+        raise NotImplementedError(f"不支持or运算")
+
+    def __call__(self, *args, **kwargs):
+        return self
+
+    def __repr__(self):
+        return f"<Trigger {self.conditions}>"
+
+    __str__ = __repr__
+
+
+__all__ = ["Trigger", "Condition"]

quantification/core/strategy/base_use.py

@@ -0,0 +1,69 @@
+import inspect
+from abc import ABC, abstractmethod
+from typing import Generator, Callable, TYPE_CHECKING
+
+from ..util import inject
+
+if TYPE_CHECKING:
+    from ..trader import BaseOrder, Result
+
+OrderGenerator = Generator["BaseOrder", "Result", None]
+CommonFunc = Callable[..., None]
+GeneratorFunc = Callable[..., OrderGenerator]
+Func = CommonFunc | GeneratorFunc
+
+
+class Injection(ABC):
+    name: str
+
+    @abstractmethod
+    def __init__(self, *args, **kwargs) -> None:
+        raise NotImplementedError
+
+    def __init_subclass__(cls, **kwargs):
+        assert hasattr(cls, "name"), \
+            "Injection类需要指定参数名"
+
+        assert isinstance(cls.name, str), \
+            "Injection指定的参数名必须为str"
+
+    @abstractmethod
+    def __call__(self, **kwargs):
+        raise NotImplementedError
+
+
+class Use:
+    def __init__(self, injection: type[Injection]):
+        self.injection = injection
+
+    def __call__(self, *args, **kwargs):
+        def wrapper(func: Func | WrappedFunc) -> WrappedFunc:
+            wrapped_func = func if isinstance(func, WrappedFunc) else WrappedFunc(func)
+            wrapped_func.register(self.injection(*args, **kwargs))
+            return wrapped_func
+
+        return wrapper
+
+
+class WrappedFunc:
+    def __init__(self, func: Func):
+        self.func = func
+        self.injections: list[Injection] = []
+
+    def register(self, injection: Injection):
+        self.injections.append(injection)
+
+    def __call__(self, **kwargs):
+        result = inject(self.func, **{
+            **kwargs,
+            **{injection.name: injection(**kwargs) for injection in self.injections}
+        })
+        return result if not inspect.isgenerator(result) else (yield from result)
+
+    def __repr__(self) -> str:
+        return f"<WrappedFunc {self.func.__name__}>"
+
+    __str__ = __repr__
+
+
+__all__ = ["Use", "Injection", "WrappedFunc", "Func"]

quantification/core/trader/__init__.py

@@ -0,0 +1,7 @@
+from .base_stage import BaseStage
+from .base_order import BaseOrder, Result
+from .base_trader import BaseTrader
+
+from .order import StockOrder
+from .query import Query
+from .portfolio import Portfolio

quantification/core/trader/base_order.py

@@ -0,0 +1,45 @@
+from typing import TypeVar, Generic, TYPE_CHECKING
+from abc import ABC, abstractmethod
+
+if TYPE_CHECKING:
+    from ..asset import BaseAsset
+
+AssetType = TypeVar('AssetType', bound="BaseAsset")
+
+
+class BaseOrder(Generic[AssetType], ABC):
+    def __init__(self, asset: AssetType, category: str, *args, **kwargs):
+        self.asset = asset
+        self.category = category
+
+    def type(self):
+        return self.__class__.__name__
+
+    @property
+    @abstractmethod
+    def extra(self):
+        raise NotImplementedError
+
+    @abstractmethod
+    def __repr__(self):
+        raise NotImplementedError
+
+    __str__ = __repr__
+
+
+OrderType = TypeVar('OrderType', bound=BaseOrder)
+
+
+class Result(Generic[OrderType]):
+    def __init__(self, *, order: OrderType, sold: list["BaseAsset"], brought: list["BaseAsset"]):
+        self.order = order
+        self.sold = sold
+        self.brought = brought
+
+    def __repr__(self):
+        return f"<Result sold={self.sold} brought={self.brought}>"
+
+    __str__ = __repr__
+
+
+__all__ = ['BaseOrder', 'Result']

quantification/core/trader/base_stage.py

@@ -0,0 +1,16 @@
+from enum import Flag
+from datetime import time
+
+
+class BaseStage(Flag):
+    @property
+    def time(self) -> time:
+        raise NotImplementedError
+
+    def __repr__(self):
+        return self.name
+
+    __str__ = __repr__
+
+
+__all__ = ['BaseStage']