fix: correct module path in odds-kenpom workflow

Updated the command in the odds-kenpom workflow to use the correct module path for the odds_pipeline schema execution.

Author: omalleyandy

.github/workflows/odds-kenpom.yml

@@ -21,7 +21,7 @@ jobs:
         env:
           DATABASE_URL: ${{ secrets.DATABASE_URL }}
         working-directory: odds
-        run: uv run python -m odds_pipeline schema
+        run: uv run python -m odds_pipeline.schema
 
       - name: Collect KenPom ratings
         env:

odds/src/odds_pipeline/collect_kenpom.py

@@ -0,0 +1,142 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from datetime import date
+
+from odds_pipeline.config import load_settings
+from odds_pipeline.db import connect
+from odds_pipeline.util import now_utc
+
+
+@dataclass(frozen=True)
+class KenPomAuth:
+    email: str
+    password: str
+
+
+def _require_auth() -> KenPomAuth:
+    import os
+
+    email = os.getenv("KENPOM_EMAIL")
+    password = os.getenv("KENPOM_PASSWORD")
+    if not email or not password:
+        raise RuntimeError("KENPOM_EMAIL and KENPOM_PASSWORD are required for kenpompy scraping")
+    return KenPomAuth(email=email, password=password)
+
+
+def collect_kenpom_team_metrics(*, season: int, metric_type: str) -> int:
+    """
+    Collect KenPom metrics via kenpompy scraping.
+
+    metric_type supported:
+    - pomeroy_ratings
+    - efficiency
+    - four_factors
+    """
+    settings = load_settings()
+    auth = _require_auth()
+
+    # Import locally so dependency is optional outside this pipeline.
+    from kenpompy.utils import login
+    from kenpompy import misc, summary
+
+    browser = login(auth.email, auth.password)
+
+    if metric_type == "pomeroy_ratings":
+        df = misc.get_pomeroy_ratings(browser, season=str(season))
+    elif metric_type == "efficiency":
+        df = summary.get_efficiency(browser, season=str(season))
+    elif metric_type == "four_factors":
+        df = summary.get_fourfactors(browser, season=str(season))
+    else:
+        raise ValueError(f"Unsupported metric_type: {metric_type}")
+
+    collected_at = now_utc()
+    inserted = 0
+
+    # Store one JSON row per team (best-effort: locate a likely team column).
+    records = df.to_dict(orient="records")
+    team_key = None
+    for candidate in ("Team", "team", "TEAM"):
+        if records and candidate in records[0]:
+            team_key = candidate
+            break
+    if team_key is None:
+        # Fall back: store as a single blob under team='__all__'
+        records = [{"__all__": True, "rows": records}]
+        team_key = "__all__"
+
+    with connect(settings.database_url) as conn:
+        with conn.cursor() as cur:
+            for r in records:
+                team = str(r.get(team_key) or "__unknown__")
+                cur.execute(
+                    """
+                    INSERT INTO raw_kenpom_team_metrics (
+                      season, team, metric_type, collected_at, raw
+                    ) VALUES (
+                      %(season)s, %(team)s, %(metric_type)s, %(collected_at)s, %(raw)s
+                    )
+                    ON CONFLICT DO NOTHING
+                    """,
+                    {
+                        "season": int(season),
+                        "team": team,
+                        "metric_type": metric_type,
+                        "collected_at": collected_at,
+                        "raw": json.dumps(r),
+                    },
+                )
+                inserted += cur.rowcount
+        conn.commit()
+
+    return inserted
+
+
+def collect_kenpom_fanmatch(*, game_date: date) -> int:
+    """
+    Collect KenPom FanMatch predictions for a given date via kenpompy.
+    """
+    settings = load_settings()
+    auth = _require_auth()
+
+    from kenpompy.utils import login
+    from kenpompy.FanMatch import FanMatch
+
+    browser = login(auth.email, auth.password)
+    fm = FanMatch(browser, date=game_date.isoformat())
+    df = fm.fm_df
+    if df is None:
+        return 0
+
+    collected_at = now_utc()
+    inserted = 0
+    records = df.to_dict(orient="records")
+
+    with connect(settings.database_url) as conn:
+        with conn.cursor() as cur:
+            for r in records:
+                # FanMatch rows may have matchup/team columns; store under team='__fanmatch__'
+                cur.execute(
+                    """
+                    INSERT INTO raw_kenpom_team_metrics (
+                      season, team, metric_type, collected_at, raw
+                    ) VALUES (
+                      %(season)s, %(team)s, %(metric_type)s, %(collected_at)s, %(raw)s
+                    )
+                    ON CONFLICT DO NOTHING
+                    """,
+                    {
+                        "season": int(game_date.year),
+                        "team": "__fanmatch__",
+                        "metric_type": "fanmatch",
+                        "collected_at": collected_at,
+                        "raw": json.dumps(r),
+                    },
+                )
+                inserted += cur.rowcount
+        conn.commit()
+
+    return inserted
+

odds/src/odds_pipeline/config.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from datetime import timedelta
+from os import getenv
+
+from pydantic import BaseModel, Field
+
+
+class Settings(BaseModel):
+    database_url: str = Field(..., description="Postgres connection string", alias="DATABASE_URL")
+    odds_api_key: str | None = Field(default=None, description="API key for collectors", alias="ODDS_API_KEY")
+
+    # Defaults for orchestration. Override via env vars if needed.
+    window_days: int = Field(default=5, alias="WINDOW_DAYS")
+    odds_stale_minutes: int = Field(default=180, alias="ODDS_STALE_MINUTES")
+    scores_stale_hours: int = Field(default=24, alias="SCORES_STALE_HOURS")
+
+    @property
+    def window(self) -> timedelta:
+        return timedelta(days=int(self.window_days))
+
+    @property
+    def odds_stale_for(self) -> timedelta:
+        return timedelta(minutes=int(self.odds_stale_minutes))
+
+    @property
+    def scores_stale_for(self) -> timedelta:
+        return timedelta(hours=int(self.scores_stale_hours))
+
+
+def load_settings() -> Settings:
+    # Pydantic v2 supports reading env via model_validate with dict.
+    env = {
+        "DATABASE_URL": getenv("DATABASE_URL"),
+        "ODDS_API_KEY": getenv("ODDS_API_KEY"),
+        "WINDOW_DAYS": getenv("WINDOW_DAYS"),
+        "ODDS_STALE_MINUTES": getenv("ODDS_STALE_MINUTES"),
+        "SCORES_STALE_HOURS": getenv("SCORES_STALE_HOURS"),
+    }
+    # Remove None keys so defaults apply.
+    env = {k: v for k, v in env.items() if v is not None}
+    return Settings.model_validate(env)
+