Add minute bar feature pipeline

pipeline/alpha/base.py

@@ -5,7 +5,7 @@ position weights. Subclasses implement :meth:`signal` — the raw, unnormalized
 score. The base class turns a signal into cross-sectionally z-scored weights
 via :meth:`to_weights` (override it for a different normalization).
 """
-from abc import ABC, abstractmethod
+from abc import ABC
 
 import numpy as np
 import pandas as pd
@@ -15,15 +15,14 @@ class BaseAlpha(ABC):
     """A position-weight alpha over a cross-section of stocks.
 
     Concrete subclasses must set a unique class-level :attr:`name` (the registry
-    key) and implement :meth:`signal`. Construct subclasses with their own typed
-    parameters (e.g. ``lookback``); the factory passes only the parameters a
-    given ``__init__`` accepts.
+    key) and implement either :meth:`signal` or :meth:`signal_from_data`.
+    Construct subclasses with their own typed parameters (e.g. ``lookback``);
+    the factory passes only the parameters a given ``__init__`` accepts.
     """
 
     #: Unique registry key. Every concrete alpha must set this to a non-empty str.
     name: str = ""
 
-    @abstractmethod
     def signal(self, close: pd.DataFrame) -> pd.DataFrame:
         """Compute the raw signal.
 
@@ -34,6 +33,21 @@ class BaseAlpha(ABC):
             A wide DataFrame aligned to ``close`` where higher values indicate a
             stronger long. Use NaN where the signal is undefined.
         """
+        raise NotImplementedError(
+            f"{type(self).__name__} must implement signal() or signal_from_data()"
+        )
+
+    def signal_from_data(
+        self,
+        data: pd.DataFrame,
+        close: pd.DataFrame,
+    ) -> pd.DataFrame:
+        """Compute the raw signal from long daily data plus wide closes.
+
+        Feature-aware alphas can override this to pivot joined feature columns
+        from ``data``. The default preserves the existing close-only alpha API.
+        """
+        return self.signal(close)
 
     def to_weights(self, signal: pd.DataFrame) -> pd.DataFrame:
         """Cross-sectionally z-score a signal into signed position weights.

pipeline/alpha/cli.py

@@ -56,6 +56,10 @@ def list_(alpha_modules):
 @click.option("--output-dir", default="alphas", help="Directory to save alpha parquet")
 @click.option("--lookback", default=5, type=int, help="Lookback days")
 @click.option("--vol-window", default=20, type=int, help="Volatility window (reversal_vol only)")
+@click.option(
+    "--feature-path", "feature_paths", multiple=True,
+    help="Daily feature parquet file/dataset to left-join on symbol_id,date (repeatable)",
+)
 @click.option(
     "--alpha-module", "alpha_modules", multiple=True,
     help="External module(s) to import so their alphas register (dotted path or .py file)",
@@ -74,7 +78,7 @@ def list_(alpha_modules):
     help="Most-liquid names kept per date when --liquid-universe is set",
 )
 def compute(data_path, alpha_name, alpha_type, output_dir, lookback, vol_window,
-            alpha_modules, extra_params, liquid_universe, universe_top_n):
+            feature_paths, alpha_modules, extra_params, liquid_universe, universe_top_n):
     """Compute one alpha from raw data and save as parquet."""
     for spec in alpha_modules:
         load_alpha_module(spec)
@@ -100,6 +104,7 @@ def compute(data_path, alpha_name, alpha_type, output_dir, lookback, vol_window,
         alpha_name=alpha_name,
         alpha_type=alpha_type,
         universe=universe,
+        feature_paths=feature_paths,
         **params,
     )
 

pipeline/alpha/compute.py

@@ -7,12 +7,15 @@ through :mod:`pipeline.alpha.registry`.
 """
 
 import logging
+from pathlib import Path
+from typing import Iterable
 
 import numpy as np
 import pandas as pd
 
 from pipeline.alpha.registry import get_alpha
 from pipeline.common.schema import ALPHA_COLUMNS
+from pipeline.features.compute import FEATURE_KEY_COLUMNS, read_feature_frames, validate_feature_frame
 
 logger = logging.getLogger(__name__)
 
@@ -33,6 +36,38 @@ def _pivot_open(df: pd.DataFrame) -> pd.DataFrame:
     return pivot.sort_index()
 
 
+def join_feature_frames(
+    data: pd.DataFrame,
+    feature_frames: Iterable[pd.DataFrame],
+) -> pd.DataFrame:
+    """Left-join validated daily feature frames onto long daily data."""
+    out = data.copy()
+    out["date"] = pd.to_datetime(out["date"])
+    existing = set(out.columns)
+    joined_cols: list[str] = []
+
+    for frame in feature_frames:
+        features = validate_feature_frame(frame)
+        feature_cols = [col for col in features.columns if col not in FEATURE_KEY_COLUMNS]
+        overlap = sorted(existing.intersection(feature_cols))
+        if overlap:
+            raise ValueError(
+                f"Feature columns conflict with existing daily data columns: {overlap}"
+            )
+        out = out.merge(
+            features,
+            on=FEATURE_KEY_COLUMNS,
+            how="left",
+            validate="many_to_one",
+        )
+        existing.update(feature_cols)
+        joined_cols.extend(feature_cols)
+
+    if joined_cols:
+        logger.info("Joined feature columns into daily data: %s", joined_cols)
+    return out
+
+
 def _forward_open_to_open_returns(open_: pd.DataFrame) -> pd.DataFrame:
     """Return earned by a close-formed signal after next-open execution.
 
@@ -105,6 +140,8 @@ def compute_alpha(
     alpha_name: str,
     alpha_type: str,
     universe: dict | None = None,
+    feature_paths: Iterable[str | Path] | None = None,
+    feature_frames: Iterable[pd.DataFrame] | None = None,
     **params,
 ) -> pd.DataFrame:
     """Compute alpha weights from raw data.
@@ -118,6 +155,10 @@ def compute_alpha(
             :func:`investable_universe_mask`) *before* it is turned into
             weights, so unheld names get weight 0. Keys are forwarded as keyword
             arguments to :func:`investable_universe_mask`.
+        feature_paths: Optional parquet files/datasets keyed by ``symbol_id``
+            and ``date``. Their numeric feature columns are left-joined onto
+            ``data`` before alpha logic runs.
+        feature_frames: Optional in-memory feature frames with the same schema.
         **params: Constructor parameters for the alpha (e.g. ``lookback``,
             ``vol_window``). Only the params the alpha's ``__init__`` accepts are
             used; extras are ignored.
@@ -128,12 +169,20 @@ def compute_alpha(
     Raises:
         KeyError: If ``alpha_type`` is not registered.
     """
+    feature_inputs: list[pd.DataFrame] = []
+    if feature_paths:
+        feature_inputs.extend(read_feature_frames(feature_paths))
+    if feature_frames:
+        feature_inputs.extend(feature_frames)
+    if feature_inputs:
+        data = join_feature_frames(data, feature_inputs)
+
     alpha = get_alpha(alpha_type, **params)
     close = _pivot_close(data)
+    signal = alpha.signal_from_data(data, close)
     if universe is None:
-        weights = alpha.weights(close)
+        weights = alpha.to_weights(signal)
     else:
-        signal = alpha.signal(close)
         mask = investable_universe_mask(data, signal, **universe)
         weights = alpha.to_weights(signal.where(mask))