akquant 0.1.4__cp310-abi3-win_amd64.whl

akquant/utils.py

@@ -0,0 +1,386 @@
+from typing import Dict, List, Optional, Tuple, Union, cast
+
+import numpy as np
+import pandas as pd
+
+from .akquant import Bar, from_arrays
+
+
+def load_bar_from_df(
+    df: pd.DataFrame,
+    symbol: Optional[str] = None,
+    column_map: Optional[Dict[str, str]] = None,
+) -> List[Bar]:
+    r"""
+    Convert DataFrame to list of akquant.Bar.
+
+    :param df: Historical market data
+    :type df: pandas.DataFrame
+    :param symbol: Symbol code; if not provided, try to use "symbol" column
+    :type symbol: str, optional
+    :param column_map: Mapping from DataFrame columns to standard fields.
+                       Defaults: date->timestamp, open->open, etc.
+    :type column_map: Dict[str, str], optional
+    :return: List of Bar objects
+    :rtype: List[Bar]
+    """
+    if df.empty:
+        return []
+
+    # Default mapping
+    required_map = {
+        "date": "timestamp",
+        "open": "open",
+        "high": "high",
+        "low": "low",
+        "close": "close",
+        "volume": "volume",
+    }
+
+    if column_map:
+        required_map.update(column_map)
+
+    # Reverse map to find dataframe columns
+    # We need to find which df column corresponds to 'timestamp', 'open', etc.
+    # required_map is DF_COL -> STANDARD_FIELD
+    # So we want to check if keys of required_map exist in df.columns
+
+    # Actually, let's flip logic slightly to be more robust.
+    # Users pass { "my_date": "date", "my_open": "open" } ?
+    # Or { "date": "my_date", "open": "my_open" } ?
+    # The previous implementation had: required_map = {"日期": "timestamp", ...}
+    # implying Key is DF Column, Value is Internal Field.
+
+    # Let's keep that convention.
+
+    # Check for required internal fields
+    internal_fields = ["timestamp", "open", "high", "low", "close", "volume"]
+
+    # Find which DF column maps to which internal field
+    field_to_col = {}
+    for col, field in required_map.items():
+        if field in internal_fields:
+            field_to_col[field] = col
+
+    # Check if all internal fields have a corresponding column in DF
+    missing_fields = []
+    for field in internal_fields:
+        if field not in field_to_col:
+            # try finding exact match in df
+            if field in df.columns:
+                field_to_col[field] = field
+            else:
+                missing_fields.append(field)
+        else:
+            if field_to_col[field] not in df.columns:
+                missing_fields.append(f"{field} (mapped to {field_to_col[field]})")
+
+    if missing_fields:
+        raise ValueError(f"DataFrame missing columns for fields: {missing_fields}")
+
+    # Vectorized Preprocessing
+
+    # 1. Handle Timestamp
+    col_date = field_to_col["timestamp"]
+    # Convert to datetime with error coercion (invalid dates becomes NaT)
+    dt_series = pd.to_datetime(df[col_date], errors="coerce")
+    # Fill NaT with 0 (Epoch 0) or handle appropriately
+    dt_series = dt_series.fillna(pd.Timestamp(0))
+    # type: ignore
+    if dt_series.dt.tz is None:
+        dt_series = dt_series.dt.tz_localize("Asia/Shanghai")
+    dt_series = dt_series.dt.tz_convert("UTC")
+    timestamps = dt_series.astype("int64").values
+
+    # 2. Extract numeric columns
+    # Use astype(float) to ensure correct type, fillna(0.0) for safety
+    opens = df[field_to_col["open"]].fillna(0.0).astype(float).values
+    highs = df[field_to_col["high"]].fillna(0.0).astype(float).values
+    lows = df[field_to_col["low"]].fillna(0.0).astype(float).values
+    closes = df[field_to_col["close"]].fillna(0.0).astype(float).values
+    volumes = df[field_to_col["volume"]].fillna(0.0).astype(float).values
+
+    # 3. Handle Symbol
+    symbols_list: Optional[List[str]] = None
+    symbol_val = None
+
+    if symbol:
+        symbol_val = symbol
+    elif "股票代码" in df.columns:
+        # Convert to string
+        symbols_list = cast(List[str], df["股票代码"].astype(str).tolist())
+    else:
+        symbol_val = "UNKNOWN"
+
+    # Call Rust extension
+    return from_arrays(
+        timestamps, opens, highs, lows, closes, volumes, symbol_val, symbols_list, None
+    )
+
+
+def parse_duration_to_bars(duration: Union[str, int], frequency: str = "1d") -> int:
+    """
+    Parse duration string to number of bars.
+
+    Assumes A-share trading hours for intraday frequencies.
+
+    :param duration: Duration string (e.g. "1y", "3m", "20d") or integer bars.
+    :param frequency: Data frequency ("1d", "1h", "1m"). Default "1d".
+    :return: Estimated number of bars.
+    """
+    if isinstance(duration, int):
+        return duration
+
+    import re
+
+    match = re.match(r"(\d+)([ymwd])", duration.lower())
+    if not match:
+        # Try to parse as int string
+        try:
+            return int(duration)
+        except ValueError:
+            raise ValueError(f"Invalid duration format: {duration}")
+
+    value = int(match.group(1))
+    unit = match.group(2)
+
+    # Estimated bars per day (A-share)
+    if frequency == "1d":
+        bars_per_day = 1
+    elif frequency == "1h":
+        bars_per_day = 4
+    elif frequency == "30m":
+        bars_per_day = 8
+    elif frequency == "15m":
+        bars_per_day = 16
+    elif frequency == "5m":
+        bars_per_day = 48
+    elif frequency == "1m":
+        bars_per_day = 240
+    else:
+        bars_per_day = 1
+
+    if unit == "y":
+        return int(value * 252 * bars_per_day)
+    elif unit == "m":
+        return int(value * 21 * bars_per_day)
+    elif unit == "w":
+        return int(value * 5 * bars_per_day)
+    elif unit == "d":
+        return int(value * bars_per_day)
+
+    return value
+
+
+def df_to_arrays(
+    df: pd.DataFrame, symbol: Optional[str] = None
+) -> Tuple[
+    np.ndarray,
+    np.ndarray,
+    np.ndarray,
+    np.ndarray,
+    np.ndarray,
+    np.ndarray,
+    Optional[str],
+    Optional[List[str]],
+    Optional[Dict[str, np.ndarray]],
+]:
+    r"""
+    将 DataFrame 转换为用于 DataFeed.add_arrays 的数组元组.
+
+    :param df: 输入的 DataFrame
+    :param symbol: 标的代码 (可选)
+    :return: (timestamps, opens, highs, lows, closes, volumes, symbol, symbols, extra)
+    """
+    if df.empty:
+        return (
+            np.array([], dtype=np.int64),
+            np.array([], dtype=np.float64),
+            np.array([], dtype=np.float64),
+            np.array([], dtype=np.float64),
+            np.array([], dtype=np.float64),
+            np.array([], dtype=np.float64),
+            symbol,
+            None,
+            None,
+        )
+
+    # Column Mapping Strategy
+    # Priority:
+    # 1. AKShare Chinese columns: "日期", "开盘", ...
+    # 2. Standard English columns: "date", "open", ...
+    # 3. Lowercase normalized check
+
+    # Define targets
+    targets = {
+        "timestamp": ["日期", "date", "datetime", "time", "timestamp"],
+        "open": ["开盘", "open"],
+        "high": ["最高", "high"],
+        "low": ["最低", "low"],
+        "close": ["收盘", "close"],
+        "volume": ["成交量", "volume", "vol"],
+        "symbol": ["股票代码", "symbol", "code", "ticker"],
+    }
+
+    # Resolve columns
+    df_cols = df.columns
+    df_cols_lower = [str(c).lower() for c in df_cols]
+
+    resolved = {}
+
+    for key, candidates in targets.items():
+        found = None
+        for cand in candidates:
+            if cand in df_cols:
+                found = cand
+                break
+
+        # If not found, try case-insensitive
+        if not found:
+            for cand in candidates:
+                if cand.lower() in df_cols_lower:
+                    idx = df_cols_lower.index(cand.lower())
+                    found = str(df_cols[idx])
+                    break
+
+        if found:
+            resolved[key] = found
+
+    # Check essential columns
+    missing = []
+    for essential in ["timestamp", "open", "high", "low", "close", "volume"]:
+        if essential not in resolved:
+            missing.append(essential)
+
+    if missing:
+        # If timestamp is index, handle it
+        if isinstance(df.index, pd.DatetimeIndex):
+            resolved["timestamp"] = "__index__"
+            missing = [m for m in missing if m != "timestamp"]
+
+        if missing:
+            msg = f"Missing columns: {missing}. Available: {df.columns.tolist()}"
+            raise ValueError(msg)
+
+    # 1. Handle Timestamp
+    dt_series: Union[pd.Series, pd.Index]
+    if resolved.get("timestamp") == "__index__":
+        dt_series = df.index
+    else:
+        dt_series = pd.to_datetime(df[resolved["timestamp"]], errors="coerce")
+
+    if not isinstance(dt_series, pd.DatetimeIndex):
+        dt_series = pd.to_datetime(dt_series)
+
+    dt_series = dt_series.fillna(pd.Timestamp(0))
+
+    # Handle timezone (support both Series and DatetimeIndex)
+    # Convert to Series for consistent handling
+    dt_series_s: pd.Series
+    if isinstance(dt_series, pd.Index):
+        dt_series_s = dt_series.to_series(index=dt_series)
+    else:
+        dt_series_s = cast(pd.Series, dt_series)
+
+    # Help mypy know it's a Series
+    if dt_series_s.dt.tz is None:
+        dt_series_s = dt_series_s.dt.tz_localize("Asia/Shanghai")
+    dt_series_s = dt_series_s.dt.tz_convert("UTC")
+
+    timestamps = cast(np.ndarray, dt_series_s.astype("int64").values)
+
+    # 2. Extract numeric columns
+    def get_col(name: str) -> np.ndarray:
+        return cast(np.ndarray, df[resolved[name]].fillna(0.0).astype(float).values)
+
+    opens = get_col("open")
+    highs = get_col("high")
+    lows = get_col("low")
+    closes = get_col("close")
+    volumes = get_col("volume")
+
+    # 3. Handle Symbol
+    symbols_list: Optional[List[str]] = None
+    symbol_val = None
+
+    if symbol:
+        symbol_val = symbol
+    elif "symbol" in resolved:
+        symbols_list = cast(List[str], df[resolved["symbol"]].astype(str).tolist())
+    else:
+        symbol_val = "UNKNOWN"
+
+    # 4. Handle Extra Columns
+    extra = {}
+    used_columns = set(resolved.values())
+
+    # Iterate over all columns to find numeric ones not in resolved
+    for col in df.columns:
+        if col in used_columns:
+            continue
+
+        # Try to convert to float
+        try:
+            # We use fillna(0.0) for safety, similar to other fields
+            # Check if column is numeric
+            if pd.api.types.is_numeric_dtype(df[col]):
+                extra[str(col)] = cast(
+                    np.ndarray, df[col].fillna(0.0).astype(float).values
+                )
+        except Exception:
+            # Skip non-numeric extra columns
+            pass
+
+    return (
+        timestamps,
+        opens,
+        highs,
+        lows,
+        closes,
+        volumes,
+        symbol_val,
+        symbols_list,
+        extra if extra else None,
+    )
+
+
+def prepare_dataframe(
+    df: pd.DataFrame, date_col: Optional[str] = None, tz: str = "Asia/Shanghai"
+) -> pd.DataFrame:
+    r"""
+    自动预处理 DataFrame，处理时区并生成标准时间戳列.
+
+    :param df: 输入 DataFrame
+    :param date_col: 日期列名 (若为 None 则自动探测)
+    :param tz: 默认时区 (若数据为 Naive 时间，则假定为此时区)
+    :return: 处理后的 DataFrame (包含 'timestamp' 列)
+    """
+    df = df.copy()
+
+    # 1. Auto-detect date column
+    if date_col is None:
+        candidates = ["date", "datetime", "time", "timestamp", "日期", "时间"]
+        for c in candidates:
+            if c in df.columns:
+                date_col = c
+                break
+
+    if date_col and date_col in df.columns:
+        # 2. Convert to datetime
+        dt = pd.to_datetime(df[date_col], errors="coerce")
+
+        # 3. Handle Timezone
+        if dt.dt.tz is None:
+            dt = dt.dt.tz_localize(tz)
+
+        # 4. Convert to UTC
+        dt = dt.dt.tz_convert("UTC")
+
+        # 5. Assign back
+        df[date_col] = dt
+        df["timestamp"] = dt.astype("int64")
+    else:
+        # Warn or ignore? For now silent, user might be processing non-time data?
+        pass
+
+    return df

akquant-0.1.4.dist-info/METADATA

@@ -0,0 +1,219 @@
+Metadata-Version: 2.4
+Name: akquant
+Version: 0.1.4
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: pandas>=3.0.0
+Requires-Dist: numpy>=2.4.1
+Requires-Dist: pyarrow>=14.0.0
+Requires-Dist: ruff>=0.1.0 ; extra == 'dev'
+Requires-Dist: pre-commit>=3.0.0 ; extra == 'dev'
+Requires-Dist: mypy>=1.0.0 ; extra == 'dev'
+Requires-Dist: pytest>=7.0.0 ; extra == 'dev'
+Requires-Dist: mkdocs>=1.5.0 ; extra == 'dev'
+Requires-Dist: mkdocs-material>=9.5.0 ; extra == 'dev'
+Requires-Dist: matplotlib>=3.0.0 ; extra == 'full'
+Requires-Dist: scikit-learn>=1.0.0 ; extra == 'ml'
+Requires-Dist: torch>=2.0.0 ; extra == 'ml'
+Requires-Dist: matplotlib>=3.0.0 ; extra == 'plot'
+Provides-Extra: dev
+Provides-Extra: full
+Provides-Extra: ml
+Provides-Extra: plot
+License-File: LICENSE
+Summary: High-performance quantitative trading framework based on Rust and Python
+Author: Akquant Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+
+<p align="center">
+  <img src="assets/logo.svg" alt="AKQuant" width="400">
+</p>
+
+# AKQuant
+
+**AKQuant** 是一个基于 **Rust** 和 **Python** 构建的高性能量化投研框架。它旨在结合 Rust 的极致性能和 Python 的易用性，为量化交易者提供强大的回测和研究工具。
+
+最新版本参考了 [NautilusTrader](https://github.com/nautechsystems/nautilus_trader) 和 [PyBroker](https://github.com/edtechre/pybroker) 的架构理念，引入了模块化设计、独立的投资组合管理、高级订单类型支持以及便捷的数据加载与缓存机制。
+
+📖 **[设计与开发指南 (DESIGN.md)](DESIGN.md)**: 如果你想深入了解内部架构、学习如何设计此类系统或进行二次开发，请阅读此文档。
+
+## 核心特性
+
+*   **极致性能**: 核心回测引擎采用 Rust 编写，通过 PyO3 提供 Python 接口。
+    *   **基准测试**: 在 200k K线数据的 SMA 策略回测中，AKQuant 耗时仅 **1.31s** (吞吐量 ~152k bars/sec)，相比 Backtrader (26.55s) 和 PyBroker (23.61s) 快约 **20倍**。
+    *   **Zero-Copy Access (New)**: 历史数据 (`ctx.history`) 通过 PyO3 Buffer Protocol / Numpy View 直接映射 Rust 内存，实现零拷贝访问，大幅提升 Python 端指标计算性能。
+*   **模块化架构**:
+    *   **Engine**: 事件驱动的核心撮合引擎，采用二进制堆 (BinaryHeap) 管理事件队列。
+    *   **Clock**: 参考 NautilusTrader 设计的交易时钟，精确管理交易时段 (TradingSession) 和时间流逝。
+    *   **Portfolio**: 独立的投资组合管理，支持实时权益计算。
+    *   **MarketModel**: 可插拔的市场模型，内置 A 股 T+1 和期货 T+0 规则。
+        *   **T+1 严格风控**: 针对股票/基金，严格执行 T+1 可用持仓检查，防止当日买入当日卖出（除非配置为 T+0 市场）。
+        *   **可用持仓管理**: 自动维护 `available_positions`，并扣除未成交的卖单冻结数量，防止超卖。
+*   **事件系统**:
+    *   **Timer**: 支持 `schedule(timestamp, payload)` 注册定时事件，触发 `on_timer` 回调，实现复杂的盘中定时逻辑。
+*   **风控系统 (New)**:
+    *   **独立拦截层**: 内置 `RiskManager`，在 Rust 引擎层直接拦截违规订单。
+    *   **可用持仓检查**: 下单前实时检查可用持仓（Available - Pending Sell），防止超卖违规。
+    *   **灵活配置**: 通过 `RiskConfig` 可配置最大单笔金额、最大持仓比例、黑名单等。
+*   **机器学习 (New)**:
+    *   **Walk-forward Validation**: 内置滚动训练框架，彻底杜绝未来函数。
+    *   **统一适配器**: 提供 `SklearnAdapter` 和 `PyTorchAdapter`，统一 Scikit-learn 和 PyTorch 接口。
+    *   **信号解耦**: 提倡 Signal (预测) 与 Action (执行) 分离的设计模式。
+*   **数据生态**:
+    *   **Streaming CSV (New)**: 支持流式加载超大 CSV 文件 (`DataFeed.from_csv`)，极大降低内存占用。
+    *   **Live Trading (New)**: 支持通过 `DataFeed.create_live()` 创建实时数据源，支持 CTP/Gateway 实时数据推送。
+    *   **Parquet Data Catalog (New)**: 采用 Apache Parquet 格式存储数据，相比 Pickle 读写速度更快，压缩率更高，便于跨语言使用。
+    *   **Pandas 集成**: 支持直接加载 Pandas DataFrame 数据，兼容各类数据源。
+    *   **显式订阅**: 策略通过 `subscribe` 方法明确声明所需数据，引擎自动按需加载。
+*   **多资产支持**:
+    *   **股票 (Stock)**: 默认支持 T+1，买入 100 股一手限制，印花税/过户费。
+    *   **基金 (Fund)**: 支持基金特有费率配置。
+    *   **期货 (Futures)**: 支持 T+0，保证金交易，合约乘数。
+    *   **期权 (Option)**: 支持 Call/Put，行权价，按张收费模式。
+*   **高级订单 (New)**:
+    *   **Stop Orders**: Rust 引擎原生支持止损单触发，提供 StopMarket 和 StopLimit。
+    *   **Target Position**: 内置 `order_target_value` 等辅助函数，自动计算调仓数量。
+*   **架构抽象 (New)**:
+    *   **ExecutionClient**: 抽象执行层，支持 `SimulatedExecutionClient` (内存撮合) 和 `RealtimeExecutionClient` (实盘对接)。
+    *   **DataClient**: 抽象数据层，支持 `SimulatedDataClient` (内存/回放) 和 `RealtimeDataClient` (实时流)。
+    *   **无缝切换**: 策略代码无需修改，仅需通过 `engine.use_realtime_execution()` 和 `DataFeed.create_live()` 即可切换至实盘模式。
+*   **灵活配置**:
+    *   **Typed Config (New)**: 引入 `BacktestConfig`, `StrategyConfig`, `RiskConfig` 类型化配置对象，替代散乱的 `**kwargs`，提供更好的 IDE 提示和参数校验。
+    *   **ExecutionMode**: 支持 `CurrentClose` (信号当根K线收盘成交) 和 `NextOpen` (次日开盘成交) 模式。
+*   **丰富的分析工具**:
+    *   **PerformanceMetrics**:
+        *   **收益**: Total Return, Annualized Return, Alpha.
+        *   **风险**: Max Drawdown, Sharpe Ratio, Sortino Ratio, Ulcer Index, UPI (Ulcer Performance Index).
+        *   **拟合**: Equity R² (线性回归拟合度).
+    *   **TradeAnalyzer**: 包含胜率、盈亏比、最大连续盈亏等详细交易统计，支持未结盈亏 (Unrealized PnL) 计算。
+*   **仿真增强**:
+    *   **滑点模型 (Slippage)**: 支持 Fixed (固定金额) 和 Percent (百分比) 滑点模型，模拟真实交易成本。
+    *   **成交量限制 (Volume Limit)**: 支持按 K 线成交量比例限制单笔撮合数量，并实现分批成交 (Partial Fill)。
+
+## 为什么选择 AKQuant?
+
+传统的 Python 回测框架（如 backtrader）在处理大规模数据或复杂逻辑时往往面临性能瓶颈。纯 C++/Rust 框架虽然性能优越，但开发和调试门槛较高。
+
+**AKQuant** 试图在两者之间找到平衡点：
+
+1.  **性能**: Rust 核心保证了回测速度，特别适合大规模参数优化。
+2.  **易用**: 策略编写完全使用 Python，提供类似 PyBroker 的简洁 API。
+3.  **专业**: 严格遵守中国市场交易规则（T+1、印花税、最低佣金等）。
+
+## 前置要求
+
+- **Rust**: [安装 Rust](https://www.rust-lang.org/tools/install)
+- **Python**: 3.10+
+- **Maturin**: `pip install maturin`
+
+## 安装说明
+
+### 开发模式（推荐）
+
+如果你正在开发该项目并希望更改即时生效：
+
+```bash
+maturin develop
+```
+
+## 快速开始
+
+### 1. 使用 helper 快速回测 (推荐)
+
+`AKQuant` 提供了一个类似 Zipline 的便捷入口 `run_backtest`，可以快速运行策略。
+
+```python
+import akquant
+from akquant.backtest import run_backtest
+from akquant import Strategy
+from akquant.config import BacktestConfig
+
+# 1. 定义策略
+class MyStrategy(Strategy):
+    def on_start(self):
+        # 显式订阅数据
+        self.subscribe("600000")
+
+    def on_bar(self, bar):
+        # 简单的双均线逻辑 (示例)
+        # 实际回测推荐使用 IndicatorSet 进行向量化计算
+        if self.ctx.position.size == 0:
+            self.buy(symbol=bar.symbol, quantity=100)
+        elif bar.close > self.ctx.position.avg_price * 1.1:
+            self.sell(symbol=bar.symbol, quantity=100)
+
+# 2. 配置回测
+config = BacktestConfig(
+    start_date="20230101",
+    end_date="20241231",
+    cash=500_000.0,
+    commission=0.0003
+)
+
+# 3. 运行回测
+# 自动加载数据、设置资金、费率等
+result = run_backtest(
+    strategy=MyStrategy,  # 传递类
+    config=config         # 传递配置对象
+)
+
+# 4. 查看结果
+print(f"Total Return: {result.metrics.total_return_pct:.2f}%")
+print(f"Sharpe Ratio: {result.metrics.sharpe_ratio:.2f}")
+print(f"Max Drawdown: {result.metrics.max_drawdown_pct:.2f}%")
+
+# 4. 获取详细数据 (DataFrame)
+# 绩效指标表
+print(result.metrics_df)
+# 交易记录表
+print(result.trades_df)
+# 每日持仓表
+print(result.daily_positions_df)
+```
+
+### 2. 函数式 API (Zipline 风格)
+
+如果你习惯 Zipline 或 Backtrader 的函数式写法，也可以直接使用：
+
+```python
+from akquant.backtest import run_backtest
+
+def initialize(ctx):
+    ctx.stop_loss_pct = 0.05
+
+def on_bar(ctx, bar):
+    if ctx.position.size == 0:
+        ctx.buy(symbol=bar.symbol, quantity=100)
+    elif bar.close < ctx.position.avg_price * (1 - ctx.stop_loss_pct):
+        ctx.sell(symbol=bar.symbol, quantity=100)
+
+run_backtest(
+    strategy=on_bar,
+    initialize=initialize,
+    symbol="600000",
+    start_date="20230101",
+    end_date="20231231"
+)
+```
+
+更多示例请参考 `examples/` 目录。
+
+## 结果分析
+`run_backtest` 返回的 `BacktestResult` 对象提供了丰富的数据用于后续分析：
+
+*   **`result.metrics`**: 包含 Total Return, Sharpe, Max Drawdown 等核心指标的对象。
+*   **`result.metrics_df`**: 包含上述指标的 Pandas DataFrame (单行)。
+*   **`result.trades_df`**: 包含所有已平仓交易的详细记录 (Entry/Exit Time/Price, PnL, Commission 等)。
+*   **`result.daily_positions_df`**: 包含每日持仓快照的 DataFrame。
+*   **`result.equity_curve`**: 权益曲线数据列表 `[(timestamp, equity), ...]`。
+
+## 快速链接
+

akquant-0.1.4.dist-info/RECORD

@@ -0,0 +1,19 @@
+akquant\__init__.py,sha256=zvuDLn0Z18mgCgStp9w2XP48UpDJwN0BCOcjL2TwBU8,2782
+akquant\akquant.pyd,sha256=WhshCrT5ywvajOowrBalOCdBaXOBR7FV2vfvy4lErao,1351680
+akquant\akquant.pyi,sha256=kUzpmcduLiTdRVkOL6r6JAzEdyCxqTXQ_E3Qdh7ZFPc,17470
+akquant\backtest.py,sha256=9iWyai2FduT1wIRUZQaZpYSky2rQLAQYJVH4_zvxBnk,23238
+akquant\config.py,sha256=_KdbGZIUlbtmvDcca8zmWCOnxjOR1xkxrI3LsjiLYlw,1587
+akquant\data.py,sha256=P_pHhuIJLXqfo3Bz9ZqlQTLnINitL630LZGP0wgElA8,4492
+akquant\indicator.py,sha256=EzWyrRp3Wihmg52WwOsOTFWs-xHy-D_NiVxKXZe8giA,2832
+akquant\log.py,sha256=hbouqiBsL_rxkuEXldBLeYyEHMqXcN6eAGCaar0BOOY,3872
+akquant\ml\__init__.py,sha256=85AriDIeIUl2oWZsfgRyQW4t5MRmJ5CGvZ1m2-ru0S0,124
+akquant\ml\model.py,sha256=ADUW6eno6Qj57znZysEiHd6lGsxCPT68Kt1tbRvNTs8,7379
+akquant\py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+akquant\risk.py,sha256=xmugILoPrxosjuUhKZ2mNS29hm8pNBgbQkJLxLrlHWU,1285
+akquant\sizer.py,sha256=mt3LbvVcDV1vQaGkTKCqnIlq2m2c7VH8cg6aE1ThzFI,2231
+akquant\strategy.py,sha256=UmmSjq2Dysw6c0Ske004BqMC7_utXgvPwyQMIS3rRB8,27415
+akquant\utils.py,sha256=VdEQLw4uK_jLLW8arFYGq4lt1rIJp9uPPtrgr5Ayf9E,12213
+akquant-0.1.4.dist-info\METADATA,sha256=ZNE89F9PTS70jDyXl8Z0PXbwQh-G25Psyp9KFue7UzQ,10749
+akquant-0.1.4.dist-info\WHEEL,sha256=ZMDDxh9OPoaLQ4P2dJmgI1XsENYSzjzq8fErKKVw5iE,96
+akquant-0.1.4.dist-info\licenses\LICENSE,sha256=VpuNU4v5Lu61sALJ2QfDitlg4BLocmPdAce7tQvBz3w,1075
+akquant-0.1.4.dist-info\RECORD,,

akquant-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.5)
+Root-Is-Purelib: false
+Tag: cp310-abi3-win_amd64

akquant-0.1.4.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 akquant developers
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.