Add minute bar feature pipeline

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))