| """Step 11 – Enrich benchmark panels with news-derived features. |
| |
| Lightweight post-processing that adds columns to the **L3 benchmark** |
| panels (not L2 processed) and enriches ``scenarios.parquet`` with |
| collected news context. |
| |
| New columns added to ``panel_train.parquet`` / ``panel_test.parquet``: |
| * ``filing_8k_count_30d`` (int) – 8-K filings in the past 30 days |
| * ``news_count_7d`` (int) – yfinance news articles in past 7 days |
| * ``has_press_release_7d`` (bool) – press release in past 7 days |
| |
| New column added to ``scenarios.parquet``: |
| * ``news_context`` (str, JSON) – top-5 scenario news articles |
| |
| Resume: skips if columns already exist in parquet files. |
| """ |
|
|
| from __future__ import annotations |
|
|
| import json |
| import logging |
| from pathlib import Path |
|
|
| import numpy as np |
| import pandas as pd |
|
|
| from . import config |
|
|
| logger = logging.getLogger(__name__) |
|
|
|
|
| |
| |
| |
|
|
| def _rolling_window_count( |
| panel_dates_i64: np.ndarray, |
| panel_groups: dict[str, np.ndarray], |
| events: pd.DataFrame, |
| window_days: int, |
| n_rows: int, |
| ) -> np.ndarray: |
| """Count events within a rolling calendar-day window per ticker. |
| |
| Uses cumulative-sum differencing with ``np.searchsorted`` – loops |
| over tickers that have events (typically a small subset), but each |
| iteration is pure numpy O(n log m). |
| |
| Parameters |
| ---------- |
| panel_dates_i64 : int64 nanosecond timestamps for all panel rows |
| panel_groups : dict mapping ticker → integer row indices in the panel |
| events : DataFrame with columns [ticker, date, n] (daily counts) |
| window_days : size of the look-back window (inclusive both ends) |
| n_rows : total number of rows in the panel |
| |
| Returns |
| ------- |
| np.ndarray[int64] of length *n_rows*. |
| """ |
| result = np.zeros(n_rows, dtype=np.int64) |
|
|
| if events.empty: |
| return result |
|
|
| window_ns = np.int64((window_days + 1) * 86_400_000_000_000) |
|
|
| for ticker, ev_group in events.groupby("ticker"): |
| if ticker not in panel_groups: |
| continue |
|
|
| panel_idx = panel_groups[ticker] |
| p_dates = panel_dates_i64[panel_idx] |
|
|
| ev_sorted = ev_group.sort_values("date") |
| e_dates = ev_sorted["date"].values.astype("int64") |
| e_cumsum = ev_sorted["n"].values.cumsum() |
|
|
| upper_pos = np.searchsorted(e_dates, p_dates, side="right") - 1 |
| upper_cs = np.where(upper_pos >= 0, e_cumsum[upper_pos], 0) |
|
|
| lower_dates = p_dates - window_ns |
| lower_pos = np.searchsorted(e_dates, lower_dates, side="right") - 1 |
| lower_cs = np.where(lower_pos >= 0, e_cumsum[lower_pos], 0) |
|
|
| result[panel_idx] = upper_cs - lower_cs |
|
|
| return result |
|
|
|
|
| |
| |
| |
|
|
| def _add_8k_counts(panel: pd.DataFrame, corpus_path: Path) -> pd.DataFrame: |
| """Add ``filing_8k_count_30d`` (fully vectorised, no calendar reindexing).""" |
| if "filing_8k_count_30d" in panel.columns: |
| logger.info(" filing_8k_count_30d already present – skipping") |
| return panel |
|
|
| if not corpus_path.exists(): |
| logger.warning("filing_corpus.parquet not found – filling 8k count with 0") |
| panel["filing_8k_count_30d"] = 0 |
| return panel |
|
|
| corpus = pd.read_parquet(corpus_path) |
| eightk = corpus[corpus["filing_type"] == "8-K"].copy() |
|
|
| if eightk.empty: |
| logger.info(" No 8-K filings in corpus – filling with 0") |
| panel["filing_8k_count_30d"] = 0 |
| return panel |
|
|
| panel["date"] = pd.to_datetime(panel["date"]) |
| eightk["filing_date"] = pd.to_datetime(eightk["filing_date"]) |
|
|
| daily = ( |
| eightk.groupby(["ticker", "filing_date"]) |
| .size() |
| .reset_index(name="n") |
| .rename(columns={"filing_date": "date"}) |
| ) |
|
|
| panel_dates_i64 = panel["date"].values.astype("int64") |
| panel_groups = { |
| t: idx for t, idx in panel.groupby("ticker", sort=False).indices.items() |
| } |
|
|
| panel["filing_8k_count_30d"] = _rolling_window_count( |
| panel_dates_i64, panel_groups, daily, window_days=30, n_rows=len(panel), |
| ) |
| logger.info(" Added filing_8k_count_30d") |
| return panel |
|
|
|
|
| |
| |
| |
|
|
| def _add_news_counts(panel: pd.DataFrame) -> pd.DataFrame: |
| """Add ``news_count_7d`` and ``has_press_release_7d`` from SEC 8-K filings. |
| |
| 8-K filings are material event disclosures — effectively press releases |
| filed with the SEC. For small/micro-cap companies, 8-K filings are the |
| most reliable per-ticker news source (mainstream media coverage is sparse). |
| """ |
| if "news_count_7d" in panel.columns: |
| logger.info(" news_count_7d already present – skipping") |
| return panel |
|
|
| panel["date"] = pd.to_datetime(panel["date"]) |
|
|
| |
| filings_dir = config.FILINGS_DIR |
| rows_8k: list[dict] = [] |
| if filings_dir.exists(): |
| for ticker_dir in filings_dir.iterdir(): |
| if not ticker_dir.is_dir(): |
| continue |
| ticker = ticker_dir.name |
| for filing in ticker_dir.glob("*.md"): |
| |
| |
| fname = filing.stem |
| if "8-K" not in fname.upper() and "8K" not in fname.upper(): |
| continue |
| |
| import re |
| date_match = re.search(r"(\d{4}-\d{2}-\d{2})", fname) |
| if not date_match: |
| date_match = re.search(r"(\d{4})(\d{2})(\d{2})", fname) |
| if date_match: |
| date_str = f"{date_match.group(1)}-{date_match.group(2)}-{date_match.group(3)}" |
| else: |
| continue |
| else: |
| date_str = date_match.group(1) |
| try: |
| ts = pd.Timestamp(date_str) |
| rows_8k.append({"ticker": ticker, "date": ts}) |
| except Exception: |
| continue |
|
|
| panel_dates_i64 = panel["date"].values.astype("int64") |
| panel_groups = { |
| t: idx for t, idx in panel.groupby("ticker", sort=False).indices.items() |
| } |
|
|
| if rows_8k: |
| filing_df = pd.DataFrame(rows_8k) |
| filing_df["date"] = pd.to_datetime(filing_df["date"]).dt.normalize() |
| daily_8k = filing_df.groupby(["ticker", "date"]).size().reset_index(name="n") |
| logger.info(" Found %d 8-K filing events across %d tickers", |
| len(daily_8k), filing_df["ticker"].nunique()) |
| panel["news_count_7d"] = _rolling_window_count( |
| panel_dates_i64, panel_groups, daily_8k, |
| window_days=7, n_rows=len(panel), |
| ) |
| panel["has_press_release_7d"] = panel["news_count_7d"] > 0 |
| else: |
| logger.warning(" No 8-K filings found – filling with defaults") |
| panel["news_count_7d"] = 0 |
| panel["has_press_release_7d"] = False |
|
|
| logger.info(" Added news_count_7d and has_press_release_7d (from 8-K filings)") |
| return panel |
|
|
|
|
| |
| |
| |
|
|
| def _enrich_scenarios(scenarios_path: Path) -> None: |
| """Add ``news_context`` column to scenarios.parquet.""" |
| if not scenarios_path.exists(): |
| logger.warning("scenarios.parquet not found – skipping scenario enrichment") |
| return |
|
|
| df = pd.read_parquet(scenarios_path) |
|
|
| if "news_context" in df.columns: |
| logger.info(" news_context already present – skipping") |
| return |
|
|
| scenarios_dir = config.NEWS_DIR / "scenarios" |
| contexts = [] |
|
|
| for _, row in df.iterrows(): |
| sc_id = row["scenario_id"] |
| news_path = scenarios_dir / f"{sc_id}.json" |
| if news_path.exists(): |
| try: |
| articles = json.loads(news_path.read_text(encoding="utf-8")) |
| top_articles = [ |
| { |
| "title": a.get("title", ""), |
| "snippet": a.get("snippet", ""), |
| "date": a.get("date", ""), |
| } |
| for a in articles |
| ] |
| contexts.append(json.dumps(top_articles)) |
| except Exception: |
| contexts.append("[]") |
| else: |
| contexts.append("[]") |
|
|
| df["news_context"] = contexts |
| df.to_parquet(scenarios_path, index=False) |
| logger.info(" Added news_context to %d scenarios", len(df)) |
|
|
|
|
| |
| |
| |
|
|
| def run(granularity: str | None = None) -> None: |
| """Enrich L3 benchmark panels and scenarios with news-derived features.""" |
| if granularity is None: |
| granularity = config.GRANULARITY |
|
|
| benchmark_dir = config.get_benchmark_dir(granularity) |
| corpus_path = benchmark_dir / "filing_corpus.parquet" |
|
|
| for split in ("panel_train.parquet", "panel_test.parquet"): |
| panel_path = benchmark_dir / split |
| if not panel_path.exists(): |
| logger.warning("%s not found – skipping", panel_path) |
| continue |
|
|
| logger.info("Enriching %s …", split) |
| panel = pd.read_parquet(panel_path) |
|
|
| panel = _add_8k_counts(panel, corpus_path) |
| panel.to_parquet(panel_path, index=False) |
| logger.info(" Checkpoint: saved after 8-K enrichment") |
|
|
| panel = _add_news_counts(panel) |
| panel.to_parquet(panel_path, index=False) |
| logger.info( |
| " Saved enriched %s (%d rows, %d cols)", |
| split, len(panel), len(panel.columns), |
| ) |
|
|
| scenarios_path = benchmark_dir / "scenarios.parquet" |
| _enrich_scenarios(scenarios_path) |
|
|
| logger.info("Benchmark enrichment complete.") |
|
|
