databank/scripts/run_analyzers.py

"""Run selected analyzers over existing DB data or last run results.

This is a scaffold to wire analyzers end-to-end once implementations are ready.
"""

from __future__ import annotations

import os
from typing import Iterable, List

from databank.db import MongoDB
from databank.analytics.base import AnalyticsBase
from databank.analytics.teams import TeamExtractorAnalyzer
from databank.analytics.elo import EloAnalyzer
from databank.analytics.dixon_coles import DixonColesAnalyzer
from databank.analytics.markov_chain import MarkovChainAnalyzer
from databank.analytics.h2h import H2HAnalyzer
from databank.analytics.calibration import CalibrationAnalyzer
from databank.analytics.monte_carlo import SeasonMonteCarloAnalyzer
from databank.analytics.sos import StrengthOfScheduleAnalyzer


def load_data(db: MongoDB, limit: int | None = 2000) -> List[dict]:
    """Load match documents from DB as analyzer inputs (scaffold)."""
    # NOTE: Adjust projection to include what analyzers need.
    return db.find("match", projection={"_id": 0}, limit=limit)


def main() -> None:
    """Build analyzers and run them on existing data (skeleton)."""
    uri = os.getenv("DATABANK_DB_URI", "mongodb://localhost:27017")
    name = os.getenv("DATABANK_DB_NAME", "databank")

    db = MongoDB(uri=uri, name=name)
    db.connect()

    data = load_data(db)

    analyzers: Iterable[AnalyticsBase] = [
        TeamExtractorAnalyzer(),
        EloAnalyzer(),
        DixonColesAnalyzer(),
        MarkovChainAnalyzer(),
        H2HAnalyzer(),
        CalibrationAnalyzer(),
        StrengthOfScheduleAnalyzer(),
        SeasonMonteCarloAnalyzer(),
    ]

    for analyzer in analyzers:
        print(f"Running analyzer: {analyzer.__class__.__name__}")
        try:
            analyzer.prepare(data)
            analyzer.validate(data)
            transformed = analyzer.transform(data)
            result = analyzer.compute(transformed, db=db, persist=True)
            analyzer.finalize(result)
            print(f" -> Done: {analyzer.__class__.__name__}")
        except NotImplementedError as exc:
            print(f" -> Skipped (not implemented): {exc}")
        except (RuntimeError, ValueError) as exc:  # pragma: no cover - diagnostics only
            print(f" -> Error: {type(exc).__name__}: {exc}")


if __name__ == "__main__":
    main()