akquant 0.1.4__cp310-abi3-win_amd64.whl

akquant/config.py

@@ -0,0 +1,65 @@
+from dataclasses import dataclass
+from typing import List, Optional
+
+
+@dataclass
+class RiskConfig:
+    """Configuration for Risk Management."""
+
+    active: bool = True
+    max_order_size: Optional[float] = None
+    max_order_value: Optional[float] = None
+    max_position_size: Optional[float] = None
+    restricted_list: Optional[List[str]] = None
+
+
+@dataclass
+class StrategyConfig:
+    """
+    Global configuration for strategies and backtesting.
+
+    Inspired by PyBroker's configuration system.
+    """
+
+    # Capital Management
+    initial_cash: float = 100000.0
+
+    # Fees & Commission
+    fee_mode: str = "per_order"  # 'per_order', 'per_share', 'percent'
+    fee_amount: float = 0.0  # Fixed amount or percentage
+
+    # Execution
+    enable_fractional_shares: bool = False
+    round_fill_price: bool = True
+
+    # Position Sizing Constraints
+    max_long_positions: Optional[int] = None
+    max_short_positions: Optional[int] = None
+
+    # Bootstrap Metrics
+    bootstrap_samples: int = 1000
+    bootstrap_sample_size: Optional[int] = None
+
+    # Other
+    exit_on_last_bar: bool = True
+
+    # Risk Config
+    risk: Optional[RiskConfig] = None
+
+
+@dataclass
+class BacktestConfig:
+    """Configuration specifically for running backtests."""
+
+    strategy_config: StrategyConfig
+    start_date: Optional[str] = None
+    end_date: Optional[str] = None
+    instruments: Optional[List[str]] = None
+    benchmark: Optional[str] = None
+    timezone: str = "Asia/Shanghai"
+    show_progress: bool = True
+    history_depth: int = 0
+
+
+# Global instance
+strategy_config = StrategyConfig()

akquant/data.py

@@ -0,0 +1,136 @@
+import hashlib
+import logging
+from pathlib import Path
+from typing import List, Optional
+
+import pandas as pd
+
+from .akquant import Bar
+from .utils import load_bar_from_df
+
+logger = logging.getLogger(__name__)
+
+
+class ParquetDataCatalog:
+    """
+    Data Catalog using Parquet files for storage.
+
+    Optimized for performance using PyArrow/FastParquet.
+    Structure: {root}/{symbol}.parquet (Simplest for now)
+    """
+
+    def __init__(self, root_path: Optional[str] = None):
+        """
+        Initialize the DataCatalog.
+
+        :param root_path: Root directory for the catalog.
+        """
+        if root_path:
+            self.root = Path(root_path)
+        else:
+            self.root = Path.home() / ".akquant" / "catalog"
+
+        try:
+            if not self.root.exists():
+                self.root.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            self.root = Path.cwd() / ".akquant_catalog"
+            self.root.mkdir(parents=True, exist_ok=True)
+
+    def write(self, symbol: str, df: pd.DataFrame) -> Path:
+        """
+        Write DataFrame to Parquet catalog.
+
+        :param symbol: Instrument symbol.
+        :param df: DataFrame with DatetimeIndex.
+        :return: Path to the written file.
+        """
+        symbol_path = self.root / symbol
+        symbol_path.mkdir(exist_ok=True)
+        file_path = symbol_path / "data.parquet"
+
+        # Ensure index is standard
+        if not isinstance(df.index, pd.DatetimeIndex):
+            # Try to convert date column if exists
+            if "date" in df.columns:
+                df = df.set_index("date")
+                df.index = pd.to_datetime(df.index)
+
+        df.to_parquet(file_path, compression="snappy")
+        return file_path
+
+    def read(
+        self,
+        symbol: str,
+        start_date: Optional[str] = None,
+        end_date: Optional[str] = None,
+        columns: Optional[List[str]] = None,
+    ) -> pd.DataFrame:
+        """
+        Read DataFrame from Parquet catalog.
+
+        :param symbol: Instrument symbol.
+        :param start_date: Filter start date (YYYYMMDD or YYYY-MM-DD).
+        :param end_date: Filter end date.
+        :param columns: Specific columns to read.
+        :return: DataFrame.
+        """
+        symbol_path = self.root / symbol
+        file_path = symbol_path / "data.parquet"
+
+        if not file_path.exists():
+            return pd.DataFrame()
+
+        # Read with projection (columns)
+        df = pd.read_parquet(file_path, columns=columns)
+
+        # Filter by date
+        if start_date:
+            df = df[df.index >= pd.to_datetime(start_date)]
+        if end_date:
+            df = df[df.index <= pd.to_datetime(end_date)]
+
+        return df
+
+    def list_symbols(self) -> List[str]:
+        """List all symbols in the catalog."""
+        return [p.name for p in self.root.iterdir() if p.is_dir()]
+
+
+class DataLoader:
+    """Data Loader with caching capabilities, inspired by PyBroker."""
+
+    def __init__(self, cache_dir: Optional[str] = None):
+        """
+        Initialize DataLoader.
+
+        Args:
+            cache_dir (str, optional): Directory to store cache files.
+                                     Defaults to ~/.akquant/cache.
+        """
+        if cache_dir:
+            self.cache_dir = Path(cache_dir)
+        else:
+            self.cache_dir = Path.home() / ".akquant" / "cache"
+
+        try:
+            if not self.cache_dir.exists():
+                self.cache_dir.mkdir(parents=True, exist_ok=True)
+        except PermissionError:
+            logger.warning(
+                f"Permission denied for {self.cache_dir}, "
+                "falling back to local .akquant_cache"
+            )
+            self.cache_dir = Path.cwd() / ".akquant_cache"
+            if not self.cache_dir.exists():
+                self.cache_dir.mkdir(parents=True, exist_ok=True)
+
+    def _get_cache_path(self, key: str) -> Path:
+        """Generate cache file path based on a unique key."""
+        # Use a hash of the key to avoid filesystem issues with long/invalid filenames
+        hashed_key = hashlib.md5(key.encode("utf-8")).hexdigest()
+        return self.cache_dir / f"{hashed_key}.pkl"
+
+    def df_to_bars(self, df: pd.DataFrame, symbol: Optional[str] = None) -> List[Bar]:
+        """Convert DataFrame to list of Bar objects."""
+        return load_bar_from_df(df, symbol)

akquant/indicator.py

@@ -0,0 +1,81 @@
+from typing import Any, Callable, Dict
+
+import pandas as pd
+
+
+class Indicator:
+    """
+    Helper class for defining and calculating indicators.
+
+    Inspired by PyBroker's indicator system.
+    """
+
+    def __init__(self, name: str, fn: Callable, **kwargs: Any) -> None:
+        """Initialize the Indicator."""
+        self.name = name
+        self.fn = fn
+        self.kwargs = kwargs
+        self._data: Dict[str, pd.Series] = {}  # symbol -> series
+
+    def __call__(self, df: pd.DataFrame, symbol: str) -> pd.Series:
+        """Calculate indicator on a DataFrame."""
+        if symbol in self._data:
+            return self._data[symbol]
+
+        # Assume fn takes a series/df and returns a series
+        # If kwargs contains column names, extract them
+        # This is a simplified version of PyBroker's powerful DSL
+        try:
+            result = self.fn(df, **self.kwargs)
+        except Exception:
+            # Try passing column if specified in kwargs
+            # e.g. rolling_mean(df['close'], window=5)
+            # This part is tricky to generalize without a full DSL,
+            # so we start simple: user passes a lambda or function that takes df
+            result = self.fn(df)
+
+        if not isinstance(result, pd.Series):
+            # Try to convert if it's not a Series (e.g. numpy array)
+            result = pd.Series(result, index=df.index)
+
+        self._data[symbol] = result
+        return result
+
+    def get_value(self, symbol: str, timestamp: Any) -> float:
+        """
+        Get indicator value at specific timestamp (or latest before it).
+
+        Uses asof lookup which is efficient for sorted time series.
+        """
+        if symbol not in self._data:
+            return float("nan")
+
+        series = self._data[symbol]
+        # Assuming series index is datetime
+        try:
+            return float(series.asof(timestamp))  # type: ignore[arg-type]
+        except Exception:
+            return float("nan")
+
+
+class IndicatorSet:
+    """Collection of indicators for easy management."""
+
+    def __init__(self) -> None:
+        """Initialize the IndicatorSet."""
+        self._indicators: Dict[str, Indicator] = {}
+
+    def add(self, name: str, fn: Callable, **kwargs: Any) -> None:
+        """Add an indicator to the set."""
+        self._indicators[name] = Indicator(name, fn, **kwargs)
+
+    def get(self, name: str) -> Indicator:
+        """Get an indicator by name."""
+        return self._indicators[name]
+
+    def calculate_all(self, df: pd.DataFrame, symbol: str) -> Dict[str, pd.Series]:
+        """Calculate all indicators for the given dataframe."""
+        results = {}
+        for name, ind in self._indicators.items():
+            results[name] = ind(df, symbol)
+        return results

akquant/log.py

@@ -0,0 +1,135 @@
+import logging
+import sys
+from typing import Optional, Union
+
+# Default format: Time | Level | Message
+DEFAULT_FORMAT = "%(asctime)s | %(levelname)s | %(message)s"
+DATE_FORMAT = "%Y-%m-%d %H:%M:%S"
+
+
+class Logger:
+    r"""
+    akquant 日志封装.
+
+    :description: 提供控制台与文件日志的快捷配置
+    """
+
+    _instance = None
+
+    def __init__(self) -> None:
+        """Initialize the Logger."""
+        self._logger = logging.getLogger("akquant")
+        self._logger.setLevel(logging.INFO)
+        self._handlers: dict[str, logging.Handler] = {}  # key -> handler
+
+        # Add default console handler if not present
+        if not self._logger.handlers:
+            self.enable_console()
+
+    @classmethod
+    def get_logger(cls) -> logging.Logger:
+        """Get the singleton logger instance."""
+        if cls._instance is None:
+            cls._instance = Logger()
+        return cls._instance._logger
+
+    def set_level(self, level: Union[str, int]) -> None:
+        r"""
+        设置日志等级.
+
+        :param level: 日志等级字符串或整数 (DEBUG/INFO/WARNING/ERROR/CRITICAL)
+        :type level: str | int
+        """
+        self._logger.setLevel(level)
+
+    def enable_console(self, format_str: str = DEFAULT_FORMAT) -> None:
+        r"""
+        启用控制台日志.
+
+        :param format_str: 日志格式字符串
+        :type format_str: str
+        """
+        if "console" in self._handlers:
+            return
+
+        handler = logging.StreamHandler(sys.stdout)
+        handler.setFormatter(logging.Formatter(format_str, datefmt=DATE_FORMAT))
+        self._logger.addHandler(handler)
+        self._handlers["console"] = handler
+
+    def disable_console(self) -> None:
+        r"""禁用控制台日志."""
+        if "console" in self._handlers:
+            self._logger.removeHandler(self._handlers["console"])
+            del self._handlers["console"]
+
+    def enable_file(
+        self, filename: str, format_str: str = DEFAULT_FORMAT, mode: str = "a"
+    ) -> None:
+        r"""
+        启用文件日志.
+
+        :param filename: 日志文件路径
+        :type filename: str
+        :param format_str: 日志格式字符串
+        :type format_str: str
+        :param mode: 文件打开模式 ('a' 追加 或 'w' 覆写)
+        :type mode: str
+        """
+        # Remove existing file handler if path matches (simple check)
+        key = f"file_{filename}"
+        if key in self._handlers:
+            return
+
+        handler = logging.FileHandler(filename, mode=mode, encoding="utf-8")
+        handler.setFormatter(logging.Formatter(format_str, datefmt=DATE_FORMAT))
+        self._logger.addHandler(handler)
+        self._handlers[key] = handler
+
+
+# Global helper functions
+def get_logger() -> logging.Logger:
+    r"""
+    获取全局 logger 实例.
+
+    :return: 已初始化的 logger
+    :rtype: logging.Logger
+    """
+    return Logger.get_logger()
+
+
+def set_log_level(level: Union[str, int]) -> None:
+    r"""
+    设置全局日志等级.
+
+    :param level: 日志等级字符串或整数
+    :type level: str | int
+    """
+    Logger.get_logger().setLevel(level)
+
+
+def register_logger(
+    filename: Optional[str] = None, console: bool = True, level: str = "INFO"
+) -> None:
+    r"""
+    日志一体化配置.
+
+    :param filename: 日志文件路径，提供则写入文件
+    :type filename: str, optional
+    :param console: 是否输出到控制台
+    :type console: bool
+    :param level: 日志等级 ("DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL")
+    :type level: str
+    """
+    logger_manager = Logger._instance or Logger()
+    Logger._instance = logger_manager
+
+    logger_manager.set_level(level.upper())
+
+    if console:
+        logger_manager.enable_console()
+    else:
+        logger_manager.disable_console()
+
+    if filename:
+        logger_manager.enable_file(filename)

akquant/ml/__init__.py

@@ -0,0 +1,3 @@
+from .model import PyTorchAdapter, QuantModel, SklearnAdapter
+
+__all__ = ["QuantModel", "SklearnAdapter", "PyTorchAdapter"]

akquant/ml/model.py

@@ -0,0 +1,234 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Any, Literal, Optional, Union
+
+import numpy as np
+import pandas as pd
+
+# Define unified data input type
+DataType = Union[np.ndarray, pd.DataFrame]
+
+
+@dataclass
+class ValidationConfig:
+    """Configuration for model validation."""
+
+    method: Literal["walk_forward"] = "walk_forward"
+    train_window: Union[str, int] = "1y"
+    test_window: Union[str, int] = (
+        "3m"  # Not strictly used in rolling execution, but useful for evaluation
+    )
+    rolling_step: Union[str, int] = "3m"
+    frequency: str = "1d"
+
+
+class QuantModel(ABC):
+    """
+    Abstract base class for all quantitative models.
+
+    The strategy layer only interacts with this class, not directly with sklearn or
+    torch.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the model."""
+        self.validation_config: Optional[ValidationConfig] = None
+
+    def set_validation(
+        self,
+        method: Literal["walk_forward"] = "walk_forward",
+        train_window: Union[str, int] = "1y",
+        test_window: Union[str, int] = "3m",
+        rolling_step: Union[str, int] = "3m",
+        frequency: str = "1d",
+    ) -> None:
+        """
+        Configure validation method (e.g., Walk-forward).
+
+        :param method: Validation method (currently only 'walk_forward').
+        :param train_window: Training data duration (e.g., '1y', '250d') or bar count.
+        :param test_window: Testing/Prediction duration (e.g., '3m') or bar count.
+        :param rolling_step: How often to retrain (e.g., '3m') or bar count.
+        :param frequency: Data frequency ('1d', '1h', '1m') used for parsing time
+            strings.
+        """
+        self.validation_config = ValidationConfig(
+            method=method,
+            train_window=train_window,
+            test_window=test_window,
+            rolling_step=rolling_step,
+            frequency=frequency,
+        )
+
+    @abstractmethod
+    def fit(self, X: DataType, y: DataType) -> None:
+        """
+        Train the model.
+
+        Args:
+            X: Training features
+            y: Training labels
+        """
+        pass
+
+    @abstractmethod
+    def predict(self, X: DataType) -> np.ndarray:
+        """
+        Predict using the model.
+
+        Args:
+            X: Input features
+
+        Returns:
+            np.ndarray: Prediction results (numpy array)
+        """
+        pass
+
+    @abstractmethod
+    def save(self, path: str) -> None:
+        """Save the model to the specified path."""
+        pass
+
+    @abstractmethod
+    def load(self, path: str) -> None:
+        """Load the model from the specified path."""
+        pass
+
+
+class SklearnAdapter(QuantModel):
+    """Adapter for Scikit-learn style models."""
+
+    def __init__(self, estimator: Any):
+        """
+        Initialize the adapter.
+
+        Args:
+            estimator: A sklearn-style estimator instance (e.g., XGBClassifier,
+                LGBMRegressor)
+        """
+        super().__init__()
+        self.model = estimator
+
+    def fit(self, X: DataType, y: DataType) -> None:
+        """Train the sklearn model."""
+        # Convert DataFrame to numpy if necessary, or let sklearn handle it
+        self.model.fit(X, y)
+
+    def predict(self, X: DataType) -> np.ndarray:
+        """Predict using the sklearn model."""
+        # For classification, we usually care about the probability of class 1
+        if hasattr(self.model, "predict_proba"):
+            # Return probability of class 1
+            # Note: This assumes binary classification. For multi-class, this might
+            # need adjustment.
+            proba = self.model.predict_proba(X)
+            if proba.shape[1] > 1:
+                return proba[:, 1]  # type: ignore
+            return proba  # type: ignore
+        else:
+            return self.model.predict(X)  # type: ignore
+
+    def save(self, path: str) -> None:
+        """Save the sklearn model using joblib."""
+        import joblib  # type: ignore
+
+        joblib.dump(self.model, path)
+
+    def load(self, path: str) -> None:
+        """Load the sklearn model using joblib."""
+        import joblib  # type: ignore
+
+        self.model = joblib.load(path)
+
+
+class PyTorchAdapter(QuantModel):
+    """Adapter for PyTorch models."""
+
+    def __init__(
+        self,
+        network: Any,
+        criterion: Any,
+        optimizer_cls: Any,
+        lr: float = 0.001,
+        epochs: int = 10,
+        batch_size: int = 64,
+        device: str = "cpu",
+    ):
+        """
+        Initialize the PyTorch adapter.
+
+        Args:
+            network: PyTorch neural network module (nn.Module)
+            criterion: Loss function (nn.Module)
+            optimizer_cls: Optimizer class (torch.optim.Optimizer)
+            lr: Learning rate
+            epochs: Number of training epochs
+            batch_size: Batch size
+            device: Device to run on ('cpu' or 'cuda')
+        """
+        super().__init__()
+        import torch
+
+        self.device = torch.device(device)
+        self.network = network.to(self.device)
+        self.criterion = criterion
+        self.optimizer = optimizer_cls(self.network.parameters(), lr=lr)
+        self.epochs = epochs
+        self.batch_size = batch_size
+
+    def fit(self, X: DataType, y: DataType) -> None:
+        """Train the PyTorch model."""
+        import torch
+        from torch.utils.data import DataLoader, TensorDataset
+
+        # 1. Data conversion: Numpy/Pandas -> Tensor
+        X_array = X.values if isinstance(X, pd.DataFrame) else X
+        y_array = (
+            y.values if isinstance(y, pd.DataFrame) or isinstance(y, pd.Series) else y
+        )
+
+        X_tensor = torch.tensor(X_array, dtype=torch.float32).to(self.device)
+        y_tensor = torch.tensor(y_array, dtype=torch.float32).to(self.device)
+
+        # 2. Wrap in DataLoader
+        dataset = TensorDataset(X_tensor, y_tensor)
+        loader = DataLoader(dataset, batch_size=self.batch_size, shuffle=True)
+
+        # 3. Standard training loop
+        self.network.train()
+        for epoch in range(self.epochs):
+            for batch_X, batch_y in loader:
+                self.optimizer.zero_grad()
+                outputs = self.network(batch_X)
+
+                # Note: Adjust loss calculation dimensions based on task
+                # (regression/classification)
+                # Squeeze outputs to match batch_y shape if necessary
+                loss = self.criterion(outputs.squeeze(), batch_y)
+
+                loss.backward()
+                self.optimizer.step()
+
+    def predict(self, X: DataType) -> np.ndarray:
+        """Predict using the PyTorch model."""
+        import torch
+
+        self.network.eval()
+        with torch.no_grad():
+            X_array = X.values if isinstance(X, pd.DataFrame) else X
+            X_tensor = torch.tensor(X_array, dtype=torch.float32).to(self.device)
+            outputs = self.network(X_tensor)
+            # Convert back to Numpy for strategy layer
+            return outputs.cpu().numpy().flatten()  # type: ignore
+
+    def save(self, path: str) -> None:
+        """Save the PyTorch model state dict."""
+        import torch
+
+        torch.save(self.network.state_dict(), path)
+
+    def load(self, path: str) -> None:
+        """Load the PyTorch model state dict."""
+        import torch
+
+        self.network.load_state_dict(torch.load(path))

akquant/risk.py

@@ -0,0 +1,40 @@
+from typing import TYPE_CHECKING, Optional
+
+from .config import RiskConfig as PyRiskConfig
+
+if TYPE_CHECKING:
+    from .akquant import Engine
+
+
+def apply_risk_config(engine: "Engine", config: Optional[PyRiskConfig]) -> None:
+    """
+    Apply Python-side RiskConfig to the Rust Engine's RiskManager.
+
+    :param engine: The backtest engine instance.
+    :param config: The Python RiskConfig object.
+    """
+    if config is None:
+        return
+
+    # Get the Rust RiskConfig object from the engine's risk manager
+    # Assuming engine.risk_manager.config is accessible and mutable
+    # Or we can create a new one and assign it
+
+    rust_config = engine.risk_manager.config
+
+    if config.max_order_size is not None:
+        rust_config.max_order_size = config.max_order_size
+
+    if config.max_order_value is not None:
+        rust_config.max_order_value = config.max_order_value
+
+    if config.max_position_size is not None:
+        rust_config.max_position_size = config.max_position_size
+
+    if config.restricted_list is not None:
+        rust_config.restricted_list = config.restricted_list
+
+    rust_config.active = config.active
+
+    # Re-assign to ensure it updates (in case it was a copy)
+    engine.risk_manager.config = rust_config