forecastops 0.1.0__py3-none-any.whl

forecastops/__init__.py

@@ -0,0 +1,24 @@
+"""ForecastOps public API."""
+
+from forecastops.core.capture import capture
+from forecastops.core.compare import compare
+from forecastops.core.diff import diff
+from forecastops.core.evaluate import evaluate
+from forecastops.core.report import report
+from forecastops.core.schema import ForecastSchema
+from forecastops.core.wrappers import forecast, instrument, wrap
+from forecastops.ui.server import ui
+
+__all__ = [
+    "ForecastSchema",
+    "capture",
+    "compare",
+    "diff",
+    "evaluate",
+    "forecast",
+    "instrument",
+    "report",
+    "ui",
+    "wrap",
+]
+

forecastops/adapters/__init__.py

@@ -0,0 +1,2 @@
+"""Forecast adapter registry and built-in adapters."""
+

forecastops/adapters/base.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from typing import Any, Protocol
+
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+
+
+class ForecastAdapter(Protocol):
+    name: str
+
+    def detect(self, obj: Any) -> DetectionResult:
+        ...
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        ...
+

forecastops/adapters/darts.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from forecastops.adapters.base import ForecastAdapter
+from forecastops.core.normalize import normalize_dataframe
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+from forecastops.core.schema import ForecastSchema
+
+
+class DartsAdapter(ForecastAdapter):
+    name = "darts"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        objects = obj if isinstance(obj, list) else [obj]
+        matched = bool(objects) and all(
+            hasattr(item, "time_index") and (hasattr(item, "values") or hasattr(item, "pd_dataframe"))
+            for item in objects
+        )
+        return DetectionResult(
+            matched,
+            0.75 if matched else 0.0,
+            "Darts TimeSeries-like object" if matched else "not a Darts TimeSeries-like object",
+        )
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        objects = obj if isinstance(obj, list) else [obj]
+        rows: list[pd.DataFrame] = []
+        for index, series in enumerate(objects):
+            if hasattr(series, "pd_dataframe"):
+                values = series.pd_dataframe()
+                if isinstance(values, pd.DataFrame):
+                    value_column = values.columns[0]
+                    frame = values.reset_index().rename(columns={values.index.name or "index": "target_time"})
+                    frame["prediction"] = frame[value_column]
+                else:
+                    raise ValueError("Darts pd_dataframe() did not return a pandas DataFrame")
+            else:
+                frame = pd.DataFrame(
+                    {
+                        "target_time": list(series.time_index),
+                        "prediction": np.asarray(series.values()).reshape(-1),
+                    }
+                )
+            frame["series_id"] = (
+                context.series_id[index]
+                if isinstance(context.series_id, list) and index < len(context.series_id)
+                else getattr(series, "components", [None])[0]
+                if hasattr(series, "components")
+                else context.series_id or f"series_{index}"
+            )
+            rows.append(frame[["series_id", "target_time", "prediction"]])
+        df = pd.concat(rows, ignore_index=True)
+        context.model_name = context.model_name or "darts"
+        schema = ForecastSchema(series_id="series_id", target_time="target_time", prediction="prediction")
+        return normalize_dataframe(df, context=context, adapter_name=self.name, schema=schema)
+

forecastops/adapters/dataframe.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from forecastops.adapters.base import ForecastAdapter
+from forecastops.core.normalize import normalize_array, normalize_dataframe
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+from forecastops.core.schema import ForecastSchema
+
+
+class GenericDataFrameAdapter(ForecastAdapter):
+    name = "dataframe"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        if not isinstance(obj, pd.DataFrame):
+            return DetectionResult(False, 0.0, "object is not a pandas DataFrame")
+        has_target = any(column in obj.columns for column in ["target_time", "ds", "timestamp"])
+        has_prediction = any(column in obj.columns for column in ["yhat", "prediction", "forecast"])
+        matched = has_target and has_prediction
+        return DetectionResult(
+            matched,
+            0.55 if matched else 0.0,
+            "generic dataframe columns found" if matched else "missing target or prediction column",
+            [] if matched else ["target_time", "prediction"],
+        )
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        return normalize_dataframe(obj, context=context, adapter_name=self.name)
+
+
+class SchemaDataFrameAdapter(ForecastAdapter):
+    name = "schema"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        matched = isinstance(obj, pd.DataFrame)
+        return DetectionResult(matched, 0.8 if matched else 0.0, "schema mapping supplied")
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        schema = context.schema
+        if not isinstance(schema, ForecastSchema):
+            raise ValueError("schema adapter requires ForecastSchema")
+        return normalize_dataframe(obj, context=context, adapter_name=self.name, schema=schema)
+
+
+class ArrayAdapter(ForecastAdapter):
+    name = "array"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        if isinstance(obj, pd.DataFrame):
+            return DetectionResult(False, 0.0, "dataframe should use dataframe adapters")
+        if hasattr(obj, "__array__") or isinstance(obj, (list, tuple)):
+            return DetectionResult(
+                True,
+                0.25,
+                "array-like object; requires explicit target_time and cutoff context",
+                ["target_time", "cutoff"],
+            )
+        return DetectionResult(False, 0.0, "object is not array-like")
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        return normalize_array(obj, context=context)
+

forecastops/adapters/gluonts.py

@@ -0,0 +1,64 @@
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import pandas as pd
+
+from forecastops.adapters.base import ForecastAdapter
+from forecastops.core.normalize import normalize_dataframe
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+from forecastops.core.schema import ForecastSchema
+
+
+class GluonTSAdapter(ForecastAdapter):
+    name = "gluonts"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        objects = obj if isinstance(obj, list) else [obj]
+        matched = bool(objects) and all(
+            hasattr(item, "start_date")
+            and hasattr(item, "prediction_length")
+            and (hasattr(item, "quantile") or hasattr(item, "samples"))
+            for item in objects
+        )
+        return DetectionResult(
+            matched,
+            0.75 if matched else 0.0,
+            "GluonTS Forecast-like object" if matched else "not a GluonTS Forecast-like object",
+        )
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        objects = obj if isinstance(obj, list) else [obj]
+        frames = []
+        for index, forecast in enumerate(objects):
+            prediction_length = int(forecast.prediction_length)
+            freq = getattr(forecast, "freq", None) or getattr(forecast.start_date, "freqstr", None) or "D"
+            start = pd.Timestamp(forecast.start_date)
+            target_time = pd.date_range(start=start, periods=prediction_length, freq=freq)
+            frame = pd.DataFrame({"target_time": target_time})
+            frame["series_id"] = getattr(forecast, "item_id", None) or context.series_id or f"item_{index}"
+            quantiles: dict[float, str] = {}
+            if hasattr(forecast, "quantile"):
+                for quantile in [0.1, 0.5, 0.9]:
+                    column = f"q{int(quantile * 100)}"
+                    frame[column] = np.asarray(forecast.quantile(quantile)).reshape(-1)
+                    quantiles[quantile] = column
+                frame["prediction"] = frame["q50"]
+            else:
+                samples = np.asarray(forecast.samples)
+                frame["prediction"] = np.median(samples, axis=0).reshape(-1)
+                frame["q10"] = np.quantile(samples, 0.1, axis=0).reshape(-1)
+                frame["q90"] = np.quantile(samples, 0.9, axis=0).reshape(-1)
+                quantiles = {0.1: "q10", 0.5: "prediction", 0.9: "q90"}
+            frames.append(frame)
+        df = pd.concat(frames, ignore_index=True)
+        context.model_name = context.model_name or "gluonts"
+        schema = ForecastSchema(
+            series_id="series_id",
+            target_time="target_time",
+            prediction="prediction",
+            quantiles=quantiles,
+        )
+        return normalize_dataframe(df, context=context, adapter_name=self.name, schema=schema)
+

forecastops/adapters/nixtla.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from forecastops.adapters.base import ForecastAdapter
+from forecastops.core.normalize import normalize_dataframe
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+from forecastops.core.schema import ForecastSchema
+
+RESERVED_COLUMNS = {"unique_id", "ds", "cutoff", "cutoff_time", "actual", "y"}
+
+
+class NixtlaAdapter(ForecastAdapter):
+    name = "nixtla"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        if not isinstance(obj, pd.DataFrame):
+            return DetectionResult(False, 0.0, "object is not a pandas DataFrame")
+        columns = set(obj.columns)
+        model_cols = [column for column in obj.columns if column not in RESERVED_COLUMNS]
+        matched = {"unique_id", "ds"}.issubset(columns) and bool(model_cols)
+        return DetectionResult(
+            matched,
+            0.9 if matched else 0.0,
+            "Nixtla-style dataframe with unique_id, ds, and model columns"
+            if matched
+            else "missing unique_id/ds/model columns",
+            [] if matched else ["unique_id", "ds", "model_col"],
+        )
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        model_col = context.adapter_options.get("model_col")
+        if model_col is None:
+            candidates = [column for column in obj.columns if column not in RESERVED_COLUMNS]
+            if not candidates:
+                raise ValueError("nixtla adapter requires at least one model output column")
+            model_col = candidates[0]
+        if model_col not in obj:
+            raise ValueError(f"model_col {model_col!r} not present in dataframe")
+        schema = ForecastSchema(
+            series_id="unique_id",
+            cutoff_time="cutoff_time" if "cutoff_time" in obj else None,
+            target_time="ds",
+            prediction=model_col,
+            actual="actual" if "actual" in obj else "y" if "y" in obj else None,
+        )
+        context.model_name = context.model_name or str(model_col)
+        return normalize_dataframe(obj, context=context, adapter_name=self.name, schema=schema)
+

forecastops/adapters/prophet.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from typing import Any
+
+import pandas as pd
+
+from forecastops.adapters.base import ForecastAdapter
+from forecastops.core.normalize import normalize_dataframe
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+from forecastops.core.schema import ForecastSchema
+
+
+class ProphetAdapter(ForecastAdapter):
+    name = "prophet"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        if not isinstance(obj, pd.DataFrame):
+            return DetectionResult(False, 0.0, "object is not a pandas DataFrame")
+        columns = set(obj.columns)
+        matched = {"ds", "yhat"}.issubset(columns)
+        confidence = 0.95 if matched and {"yhat_lower", "yhat_upper"} & columns else 0.85 if matched else 0.0
+        return DetectionResult(
+            matched,
+            confidence,
+            "Prophet-like dataframe with ds and yhat" if matched else "missing ds/yhat columns",
+        )
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        schema = ForecastSchema(
+            target_time="ds",
+            prediction="yhat",
+            lower="yhat_lower" if "yhat_lower" in obj else None,
+            upper="yhat_upper" if "yhat_upper" in obj else None,
+        )
+        if context.model_name is None:
+            context.model_name = "prophet"
+        return normalize_dataframe(obj, context=context, adapter_name=self.name, schema=schema)
+

forecastops/adapters/registry.py

@@ -0,0 +1,59 @@
+from __future__ import annotations
+
+from typing import Any
+
+from forecastops.adapters.base import ForecastAdapter
+from forecastops.adapters.darts import DartsAdapter
+from forecastops.adapters.dataframe import (
+    ArrayAdapter,
+    GenericDataFrameAdapter,
+    SchemaDataFrameAdapter,
+)
+from forecastops.adapters.gluonts import GluonTSAdapter
+from forecastops.adapters.nixtla import NixtlaAdapter
+from forecastops.adapters.prophet import ProphetAdapter
+from forecastops.adapters.sklearn import SklearnArrayAdapter
+from forecastops.core.run import CaptureContext
+
+_CUSTOM_ADAPTERS: dict[str, ForecastAdapter] = {}
+
+
+def adapter(name: str):
+    def decorator(cls: type[ForecastAdapter]) -> type[ForecastAdapter]:
+        _CUSTOM_ADAPTERS[name] = cls()
+        return cls
+
+    return decorator
+
+
+def builtin_adapters() -> list[ForecastAdapter]:
+    return [
+        DartsAdapter(),
+        GluonTSAdapter(),
+        ProphetAdapter(),
+        NixtlaAdapter(),
+        GenericDataFrameAdapter(),
+        SklearnArrayAdapter(),
+        ArrayAdapter(),
+    ]
+
+
+def resolve_adapter(obj: Any, adapter_name: str | None, context: CaptureContext) -> ForecastAdapter:
+    if adapter_name:
+        if adapter_name == "schema":
+            return SchemaDataFrameAdapter()
+        adapters = {adapter.name: adapter for adapter in [*_CUSTOM_ADAPTERS.values(), *builtin_adapters()]}
+        if adapter_name not in adapters:
+            raise ValueError(f"Unknown adapter {adapter_name!r}")
+        return adapters[adapter_name]
+    if context.schema is not None:
+        return SchemaDataFrameAdapter()
+
+    candidates: list[tuple[float, ForecastAdapter]] = []
+    for candidate in [*_CUSTOM_ADAPTERS.values(), *builtin_adapters()]:
+        result = candidate.detect(obj)
+        if result.matched:
+            candidates.append((result.confidence, candidate))
+    if not candidates:
+        raise ValueError("Could not detect a ForecastOps adapter. Supply adapter= or schema= explicitly.")
+    return sorted(candidates, key=lambda item: item[0], reverse=True)[0][1]

forecastops/adapters/sklearn.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import Any
+
+from forecastops.adapters.dataframe import ArrayAdapter
+from forecastops.core.run import CaptureContext, DetectionResult, NormalizedForecast
+
+
+class SklearnArrayAdapter(ArrayAdapter):
+    name = "sklearn"
+
+    def detect(self, obj: Any) -> DetectionResult:
+        result = super().detect(obj)
+        if not result.matched:
+            return result
+        return DetectionResult(
+            True,
+            0.2,
+            "array-like model predictions; explicit target_time and cutoff context required",
+            ["target_time", "cutoff"],
+        )
+
+    def normalize(self, obj: Any, *, context: CaptureContext) -> NormalizedForecast:
+        context.model_name = context.model_name or "sklearn"
+        normalized = super().normalize(obj, context=context)
+        normalized.adapter_name = self.name
+        return normalized
+

forecastops/cli/__init__.py

@@ -0,0 +1,2 @@
+"""Command line interface."""
+

forecastops/cli/main.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import pandas as pd
+import typer
+import yaml
+
+from forecastops.adapters.registry import resolve_adapter
+from forecastops.core.capture import capture
+from forecastops.core.compare import compare as compare_run
+from forecastops.core.config import load_config, write_default_config
+from forecastops.core.diff import diff as diff_runs
+from forecastops.core.evaluate import evaluate as evaluate_run
+from forecastops.core.report import report as generate_report
+from forecastops.core.run import CaptureContext
+from forecastops.core.schema import ForecastSchema
+from forecastops.core.validate import validate_forecast
+from forecastops.store.duckdb_index import DuckDBIndex
+from forecastops.store.local import LocalStore
+from forecastops.store.parquet import read_artifact
+from forecastops.ui.server import ui as launch_ui
+
+app = typer.Typer(help="ForecastOps local forecast observability.")
+
+
+@app.command()
+def init(
+    store: Path = typer.Option(Path(".forecastops"), help="Local ForecastOps store path."),
+    config: Path = typer.Option(Path("forecastops.yaml"), help="Config file path."),
+) -> None:
+    local_store = LocalStore.from_path(store)
+    local_store.init()
+    DuckDBIndex(local_store).init()
+    write_default_config(config)
+    typer.echo(f"Initialized {local_store.root}")
+
+
+@app.command("capture")
+def capture_file(
+    forecast_path: Path = typer.Argument(..., help="Forecast dataframe file."),
+    project: str = typer.Option("default", help="Project name."),
+    schema: Path | None = typer.Option(None, help="YAML schema mapping."),
+    adapter: str | None = typer.Option(None, help="Adapter name."),
+    cutoff: str | None = typer.Option(None, help="Forecast cutoff time."),
+    series_id: str | None = typer.Option(None, help="Single series id."),
+    actuals: Path | None = typer.Option(None, help="Actuals dataframe file."),
+    benchmark: Path | None = typer.Option(None, help="Benchmark dataframe file."),
+    benchmark_name: str = typer.Option("benchmark", help="Benchmark name."),
+    model_name: str | None = typer.Option(None, help="Model name."),
+    store: Path | None = typer.Option(None, help="Local store path."),
+) -> None:
+    forecast = _read_frame(forecast_path)
+    run = capture(
+        forecast,
+        project=project,
+        schema=_read_schema(schema),
+        adapter=adapter,
+        cutoff=cutoff,
+        series_id=series_id,
+        actuals=_read_frame(actuals) if actuals else None,
+        benchmark=_read_frame(benchmark) if benchmark else None,
+        benchmark_name=benchmark_name,
+        model_name=model_name,
+        store=store,
+    )
+    typer.echo(json.dumps({"run_id": run.run_id, "status": run.status}, indent=2))
+
+
+@app.command()
+def lint(
+    forecast_path: Path = typer.Argument(..., help="Forecast dataframe file."),
+    schema: Path | None = typer.Option(None, help="YAML schema mapping."),
+    adapter: str | None = typer.Option(None, help="Adapter name."),
+    project: str = typer.Option("lint", help="Project context."),
+    cutoff: str | None = typer.Option(None, help="Forecast cutoff time."),
+    series_id: str | None = typer.Option(None, help="Single series id."),
+    allow_insample: bool = typer.Option(False, help="Allow target_time <= cutoff_time."),
+) -> None:
+    frame = _read_frame(forecast_path)
+    schema_obj = _read_schema(schema)
+    context = CaptureContext(
+        project=project,
+        run_id="lint",
+        cutoff=cutoff,
+        series_id=series_id,
+        schema=schema_obj,
+        model_name="lint",
+    )
+    adapter_impl = resolve_adapter(frame, adapter, context)
+    normalized = adapter_impl.normalize(frame, context=context).frame
+    events = validate_forecast(normalized, allow_insample=allow_insample)
+    for event in events:
+        typer.echo(
+            f"{event.severity:<5} {event.code}: {event.message}"
+            + (f" ({event.affected_count})" if event.affected_count else "")
+        )
+    if any(event.is_error for event in events):
+        raise typer.Exit(1)
+
+
+@app.command()
+def evaluate(
+    run_id: str = typer.Argument(..., help="Run id."),
+    actuals: Path | None = typer.Option(None, help="Actuals dataframe file."),
+    store: Path | None = typer.Option(None, help="Local store path."),
+) -> None:
+    index = DuckDBIndex(LocalStore.from_path(store))
+    run = index.run_by_id(run_id)
+    if not run:
+        raise typer.BadParameter(f"Run {run_id!r} not found")
+    result = evaluate_run(
+        read_artifact(run["forecast_artifact_uri"]),
+        run_id=run_id,
+        actuals=_read_frame(actuals) if actuals else None,
+    )
+    index.insert_metrics(result.metrics)
+    typer.echo(result.to_frame().to_string(index=False))
+
+
+@app.command()
+def compare(
+    run_id: str = typer.Argument(..., help="Run id."),
+    benchmark: Path = typer.Option(..., help="Benchmark dataframe file."),
+    benchmark_name: str = typer.Option("benchmark", help="Benchmark name."),
+    store: Path | None = typer.Option(None, help="Local store path."),
+) -> None:
+    index = DuckDBIndex(LocalStore.from_path(store))
+    run = index.run_by_id(run_id)
+    if not run:
+        raise typer.BadParameter(f"Run {run_id!r} not found")
+    result = compare_run(
+        read_artifact(run["forecast_artifact_uri"]),
+        benchmark=_read_frame(benchmark),
+        benchmark_name=benchmark_name,
+    )
+    index.insert_metrics(result.metrics)
+    typer.echo(result.to_frame().to_string(index=False))
+
+
+@app.command()
+def diff(
+    base_run_id: str = typer.Argument(..., help="Base run id."),
+    candidate_run_id: str = typer.Argument(..., help="Candidate run id."),
+    store: Path | None = typer.Option(None, help="Local store path."),
+) -> None:
+    index = DuckDBIndex(LocalStore.from_path(store))
+    base = index.run_by_id(base_run_id)
+    candidate = index.run_by_id(candidate_run_id)
+    if not base or not candidate:
+        raise typer.BadParameter("Both runs must exist")
+    result = diff_runs(base["forecast_artifact_uri"], candidate["forecast_artifact_uri"])
+    typer.echo(result.metric_deltas.to_string(index=False))
+
+
+@app.command()
+def report(
+    run_id: str | None = typer.Argument(None, help="Run id. Omit with --latest."),
+    latest: bool = typer.Option(False, help="Use latest run."),
+    out: Path | None = typer.Option(None, help="Output HTML path."),
+    store: Path | None = typer.Option(None, help="Local store path."),
+) -> None:
+    output = generate_report(None if latest or run_id is None else run_id, out=out, store=store)
+    typer.echo(str(output))
+
+
+@app.command()
+def ui(
+    host: str | None = typer.Option(None, help="Bind host."),
+    port: int | None = typer.Option(None, help="Bind port."),
+    store: Path | None = typer.Option(None, help="Local store path."),
+    no_open: bool = typer.Option(False, help="Do not open a browser window."),
+    allow_remote: bool = typer.Option(
+        False, help="Allow binding to a non-loopback host (no authentication; use with care)."
+    ),
+) -> None:
+    launch_ui(
+        host=host,
+        port=port,
+        store=store,
+        open_browser=not no_open,
+        allow_remote=allow_remote,
+    )
+
+
+@app.command()
+def doctor(store: Path | None = typer.Option(None, help="Local store path.")) -> None:
+    config = load_config()
+    local_store = LocalStore.from_path(store or config.store)
+    index = DuckDBIndex(local_store)
+    index.init()
+    latest = index.latest_run_id()
+    typer.echo(
+        json.dumps(
+            {
+                "store": str(local_store.root),
+                "db": str(local_store.db_path),
+                "latest_run_id": latest,
+                "ui": {"host": config.ui_host, "port": config.ui_port},
+                "otel_enabled": config.otel_enabled,
+            },
+            indent=2,
+        )
+    )
+
+
+def _read_frame(path: Path | None) -> pd.DataFrame:
+    if path is None:
+        raise ValueError("Path is required")
+    suffix = path.suffix.lower()
+    if suffix in {".parquet", ".pq"}:
+        return pd.read_parquet(path)
+    if suffix == ".csv":
+        return pd.read_csv(path)
+    if suffix in {".json", ".jsonl"}:
+        return pd.read_json(path, lines=suffix == ".jsonl")
+    raise ValueError(f"Unsupported dataframe file type: {path.suffix}")
+
+
+def _read_schema(path: Path | None) -> ForecastSchema | None:
+    if path is None:
+        return None
+    with path.open("r", encoding="utf-8") as handle:
+        data: dict[str, Any] = yaml.safe_load(handle) or {}
+    if not data:
+        return None
+    return ForecastSchema.from_dict(data.get("schema", data))

forecastops/core/__init__.py

@@ -0,0 +1,2 @@
+"""Core ForecastOps capture, evaluation, reporting, and run models."""
+