Add new daemons and debug scripts for Sigenergy and Oracle functionalities

- Implement `sigen_daemon.py` to poll Sigenergy plant metrics and store snapshots.
- Create `web_daemon.py` for serving a web interface with various endpoints.
- Add debug scripts:
  - `debug_duplicates.py` to find duplicate target times in forecast data.
  - `debug_energy_forecast.py` to print baseline energy forecast curves.
  - `debug_oracle_evaluations.py` to run the oracle evaluator.
  - `debug_sigen.py` to inspect stored Sigenergy plant snapshots.
  - `debug_weather.py` to trace resolved truth data.
  - `modbus_test.py` for exploring Sigenergy plants or inverters over Modbus TCP.
- Introduce `oracle_evaluator.py` for evaluating stored oracle predictions against actuals.
- Add TCN training scripts in `tcn` directory for training usage sequence models.

gibil/scripts/daemons/db_daemon.py

@@ -0,0 +1,137 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timedelta, timezone
+from os import environ
+from sys import stderr
+from time import sleep
+
+from gibil.classes.env_loader import EnvLoader
+from gibil.classes.weather.builder import (
+    OpenMeteoArchiveClient,
+    OpenMeteoClient,
+    WeatherBuilder,
+)
+from gibil.classes.weather.store import WeatherStore
+
+
+@dataclass(frozen=True)
+class DbDaemonConfig:
+    latitude: float
+    longitude: float
+    forecast_hours: int
+    truth_lookback_days: int
+    truth_end_delay_days: int
+    poll_seconds: int
+
+    @classmethod
+    def from_env(cls) -> "DbDaemonConfig":
+        return cls(
+            latitude=float(_required_env("ASTRAPE_LATITUDE")),
+            longitude=float(_required_env("ASTRAPE_LONGITUDE")),
+            forecast_hours=int(environ.get("ASTRAPE_WEATHER_FORECAST_HOURS", "48")),
+            truth_lookback_days=int(
+                environ.get("ASTRAPE_WEATHER_TRUTH_LOOKBACK_DAYS", "14")
+            ),
+            truth_end_delay_days=int(
+                environ.get("ASTRAPE_WEATHER_TRUTH_END_DELAY_DAYS", "5")
+            ),
+            poll_seconds=int(environ.get("ASTRAPE_WEATHER_POLL_SECONDS", "3600")),
+        )
+
+
+class DbDaemon:
+    """Runs builder components that populate Astrape's database."""
+
+    def __init__(
+        self,
+        config: DbDaemonConfig,
+        weather_client: OpenMeteoClient,
+        archive_client: OpenMeteoArchiveClient,
+        weather_builder: WeatherBuilder,
+        weather_store: WeatherStore,
+    ) -> None:
+        self.config = config
+        self.weather_client = weather_client
+        self.archive_client = archive_client
+        self.weather_builder = weather_builder
+        self.weather_store = weather_store
+
+    @classmethod
+    def from_env(cls) -> "DbDaemon":
+        return cls(
+            config=DbDaemonConfig.from_env(),
+            weather_client=OpenMeteoClient(),
+            archive_client=OpenMeteoArchiveClient(),
+            weather_builder=WeatherBuilder(),
+            weather_store=WeatherStore.from_env(),
+        )
+
+    def initialize(self) -> None:
+        self.weather_store.initialize()
+
+    def run_once(self) -> tuple[int, int]:
+        raw_run = self.weather_client.fetch_forecast(
+            latitude=self.config.latitude,
+            longitude=self.config.longitude,
+            forecast_hours=self.config.forecast_hours,
+        )
+        forecast_run = self.weather_builder.build_forecast_run(
+            source=raw_run.source,
+            latitude=raw_run.latitude,
+            longitude=raw_run.longitude,
+            points=raw_run.points,
+            issued_at=raw_run.issued_at,
+        )
+        forecast_count = self.weather_store.save_forecast_run(forecast_run)
+        zero_hour_truth_count = self.weather_store.save_zero_hour_forecast_as_truth(
+            forecast_run
+        )
+
+        today = datetime.now(timezone.utc).date()
+        truth_end = today - timedelta(days=self.config.truth_end_delay_days)
+        truth_start = truth_end - timedelta(days=self.config.truth_lookback_days)
+        truth_points = self.archive_client.fetch_resolved_truth(
+            latitude=self.config.latitude,
+            longitude=self.config.longitude,
+            start_date=truth_start,
+            end_date=truth_end,
+        )
+        archive_truth_count = self.weather_store.save_resolved_truth(truth_points)
+
+        return forecast_count, zero_hour_truth_count + archive_truth_count
+
+    def run_forever(self) -> None:
+        self.initialize()
+        while True:
+            forecast_count, truth_count = self.run_once()
+            print(
+                f"stored_weather_forecast_points={forecast_count} "
+                f"stored_weather_resolved_truth={truth_count}",
+                flush=True,
+            )
+            sleep(self.config.poll_seconds)
+
+
+def main() -> None:
+    try:
+        EnvLoader().load()
+        daemon = DbDaemon.from_env()
+        daemon.run_forever()
+    except Exception as error:
+        print(f"db_daemon_startup_error={error}", file=stderr)
+        raise SystemExit(1) from error
+
+
+def _required_env(name: str) -> str:
+    value = environ.get(name)
+    if not value:
+        raise RuntimeError(
+            f"{name} is required. Set ASTRAPE_DATABASE_URL, "
+            "ASTRAPE_LATITUDE, and ASTRAPE_LONGITUDE before starting db_daemon."
+        )
+    return value
+
+
+if __name__ == "__main__":
+    main()