coordinator-node 0.1.2__tar.gz → 0.1.4__tar.gz

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coordinator-node
-Version: 0.1.2
+Version: 0.1.4
 Summary: Runtime engine for Crunch coordinator nodes
 Project-URL: Homepage, https://github.com/crunchdao/coordinator-node-starter
 Project-URL: Repository, https://github.com/crunchdao/coordinator-node-starter

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/base/Makefile

@@ -1,5 +1,5 @@
 # Workspace-level convenience — proxies to node/
-.PHONY: deploy down logs verify-e2e check-models
+.PHONY: deploy down logs verify-e2e check-models init-db reset-db
 
 deploy:
 	cd node && make deploy
@@ -15,3 +15,9 @@ verify-e2e:
 
 check-models:
 	cd node && make check-models
+
+init-db:
+	cd node && make init-db
+
+reset-db:
+	cd node && make reset-db

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/base/node/Dockerfile

@@ -8,7 +8,7 @@ WORKDIR /app
 
 # Coordinator engine (from PyPI)
 # Bump this to force Docker to re-pull the latest package version
-ARG COORDINATOR_NODE_VERSION=0.1.2
+ARG COORDINATOR_NODE_VERSION=0.1.4
 RUN pip install --no-cache-dir "coordinator-node>=${COORDINATOR_NODE_VERSION}"
 
 # Challenge package

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/base/node/Makefile

@@ -1,10 +1,16 @@
 COMPOSE := docker compose -f docker-compose.yml --env-file .local.env
 
-.PHONY: deploy down logs logs-capture verify-e2e check-models starter platform backfill
+.PHONY: deploy down logs logs-capture verify-e2e check-models starter platform backfill init-db reset-db
 
 deploy:
 	$(COMPOSE) up -d --build
 
+init-db:
+	$(COMPOSE) run --rm init-db
+
+reset-db:
+	$(COMPOSE) run --rm reset-db
+
 down:
 	$(COMPOSE) down
 

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/base/node/docker-compose.yml

@@ -27,6 +27,28 @@ services:
       dockerfile: node/Dockerfile
     container_name: starter-challenge-init-db
     command: ["python", "-m", "coordinator_node.db.init_db"]
+    profiles: [init]
+    environment:
+      POSTGRES_HOST: ${POSTGRES_HOST:-postgres}
+      POSTGRES_PORT: ${POSTGRES_PORT:-5432}
+      POSTGRES_USER: ${POSTGRES_USER:-starter}
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-starter}
+      POSTGRES_DB: ${POSTGRES_DB:-starter}
+      SCHEDULED_PREDICTION_CONFIGS_PATH: /app/config/scheduled_prediction_configs.json
+    volumes:
+      - ./config/scheduled_prediction_configs.json:/app/config/scheduled_prediction_configs.json:ro
+    depends_on:
+      postgres:
+        condition: service_healthy
+    networks: [coordinator-net]
+
+  reset-db:
+    build:
+      context: ..
+      dockerfile: node/Dockerfile
+    container_name: starter-challenge-reset-db
+    command: ["python", "-m", "coordinator_node.db.init_db", "--reset"]
+    profiles: [reset]
     environment:
       POSTGRES_HOST: ${POSTGRES_HOST:-postgres}
       POSTGRES_PORT: ${POSTGRES_PORT:-5432}
@@ -62,12 +84,12 @@ services:
       FEED_BACKFILL_MINUTES: ${FEED_BACKFILL_MINUTES:-180}
       FEED_RECORD_TTL_DAYS: ${FEED_RECORD_TTL_DAYS:-90}
       FEED_RETENTION_CHECK_SECONDS: ${FEED_RETENTION_CHECK_SECONDS:-3600}
-      PYTHONPATH: /app/challenge
+      PYTHONPATH: /app:/app/challenge
     volumes:
       - ../challenge:/app/challenge
     depends_on:
-      init-db:
-        condition: service_completed_successfully
+      postgres:
+        condition: service_healthy
     networks: [coordinator-net]
 
   predict-worker:
@@ -93,12 +115,12 @@ services:
       FEED_SUBJECTS: ${FEED_SUBJECTS:-BTC}
       FEED_KIND: ${FEED_KIND:-tick}
       FEED_GRANULARITY: ${FEED_GRANULARITY:-1s}
-      PYTHONPATH: /app/challenge
+      PYTHONPATH: /app:/app/challenge
     volumes:
       - ../challenge:/app/challenge
     depends_on:
-      init-db:
-        condition: service_completed_successfully
+      postgres:
+        condition: service_healthy
       model-orchestrator:
         condition: service_started
       feed-data-worker:
@@ -124,12 +146,12 @@ services:
       FEED_KIND: ${FEED_KIND:-tick}
       FEED_GRANULARITY: ${FEED_GRANULARITY:-1s}
       SCORING_FUNCTION: ${SCORING_FUNCTION}
-      PYTHONPATH: /app/challenge
+      PYTHONPATH: /app:/app/challenge
     volumes:
       - ../challenge:/app/challenge
     depends_on:
-      init-db:
-        condition: service_completed_successfully
+      postgres:
+        condition: service_healthy
       feed-data-worker:
         condition: service_started
     networks: [coordinator-net]
@@ -148,12 +170,12 @@ services:
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-starter}
       POSTGRES_DB: ${POSTGRES_DB:-starter}
       CHECKPOINT_INTERVAL_SECONDS: ${CHECKPOINT_INTERVAL_SECONDS:-604800}
-      PYTHONPATH: /app/challenge
+      PYTHONPATH: /app:/app/challenge
     volumes:
       - ../challenge:/app/challenge
     depends_on:
-      init-db:
-        condition: service_completed_successfully
+      postgres:
+        condition: service_healthy
     networks: [coordinator-net]
 
   report-worker:
@@ -171,12 +193,12 @@ services:
       POSTGRES_USER: ${POSTGRES_USER:-starter}
       POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-starter}
       POSTGRES_DB: ${POSTGRES_DB:-starter}
-      PYTHONPATH: /app/challenge
+      PYTHONPATH: /app:/app/challenge
     volumes:
       - ../challenge:/app/challenge
     depends_on:
-      init-db:
-        condition: service_completed_successfully
+      postgres:
+        condition: service_healthy
     networks: [coordinator-net]
 
   model-orchestrator:

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/coordinator_node/db/init_db.py

@@ -57,15 +57,13 @@ def load_scheduled_prediction_configs() -> list[dict[str, Any]]:
     return payload
 
 
-def init_db() -> None:
-    print("➡️  Resetting canonical tables...")
-    with engine.begin() as conn:
-        for table in tables_to_reset():
-            conn.execute(text(f"DROP TABLE IF EXISTS {table} CASCADE"))
-
-    print("➡️  Creating coordinator core tables...")
+def migrate() -> None:
+    """Create tables if they don't exist and upsert prediction configs.
+    Safe to run on every boot — never drops data."""
+    print("➡️  Creating tables (if not exist)...")
     SQLModel.metadata.create_all(engine)
 
+    print("➡️  Upserting scheduled prediction configs...")
     with create_session() as session:
         session.exec(delete(PredictionConfigRow))
         for idx, config in enumerate(load_scheduled_prediction_configs(), start=1):
@@ -83,8 +81,42 @@ def init_db() -> None:
             )
         session.commit()
 
-    print("✅ Node-template database initialization complete.")
+    print("✅ Database migration complete.")
+
+
+def reset_db() -> None:
+    """Drop all tables and recreate from scratch. Destroys all data."""
+    print("⚠️  Dropping all tables...")
+    with engine.begin() as conn:
+        for table in tables_to_reset():
+            conn.execute(text(f"DROP TABLE IF EXISTS {table} CASCADE"))
+
+    migrate()
+    print("✅ Database reset complete.")
+
+
+# Keep backward compat
+init_db = reset_db
+
+
+def auto_migrate() -> None:
+    """Run migrate if tables don't exist yet. Called by workers on boot."""
+    try:
+        from sqlalchemy import inspect as sa_inspect
+        inspector = sa_inspect(engine)
+        if not inspector.has_table("models"):
+            migrate()
+    except Exception:
+        # First boot or connection issue — try migrate anyway
+        try:
+            migrate()
+        except Exception:
+            pass
 
 
 if __name__ == "__main__":
-    init_db()
+    import sys
+    if "--reset" in sys.argv:
+        reset_db()
+    else:
+        migrate()

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/coordinator_node/db/repositories.py

@@ -168,6 +168,7 @@ class DBPredictionRepository:
             existing.meta_jsonb = row.meta_jsonb
             existing.scope_key = row.scope_key
             existing.scope_jsonb = row.scope_jsonb
+            existing.resolvable_at = row.resolvable_at
         self._session.commit()
 
     def save_all(self, predictions: Iterable[PredictionRecord]) -> None:

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/coordinator_node/db/session.py

@@ -16,6 +16,13 @@ def database_url() -> str:
 
 engine = create_engine(database_url())
 
+_migrated = False
+
 
 def create_session() -> Session:
+    global _migrated
+    if not _migrated:
+        from coordinator_node.db.init_db import auto_migrate
+        auto_migrate()
+        _migrated = True
     return Session(engine)

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/coordinator_node/services/score.py

@@ -224,7 +224,7 @@ class ScoreService:
             metrics: dict[str, float] = {}
             for window_name, window in aggregation.windows.items():
                 cutoff = now - timedelta(hours=window.hours)
-                window_snaps = [s for s in model_snapshots if s.period_end >= cutoff]
+                window_snaps = [s for s in model_snapshots if self._ensure_utc(s.period_end) >= cutoff]
                 if window_snaps:
                     vals = [float(s.result_summary.get(aggregation.ranking_key, 0)) for s in window_snaps]
                     metrics[window_name] = sum(vals) / len(vals)
@@ -270,6 +270,13 @@ class ScoreService:
 
     _rank_leaderboard = _rank
 
+    @staticmethod
+    def _ensure_utc(dt: datetime) -> datetime:
+        """Ensure a datetime is timezone-aware (assume UTC if naive)."""
+        if dt.tzinfo is None:
+            return dt.replace(tzinfo=timezone.utc)
+        return dt
+
     def _rollback_repositories(self) -> None:
         for name, repo in [("input", self.input_repository),
                            ("prediction", self.prediction_repository),

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "coordinator-node"
-version = "0.1.2"
+version = "0.1.4"
 description = "Runtime engine for Crunch coordinator nodes"
 readme = "README.md"
 requires-python = ">=3.12"

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/tests/test_node_template_predict_service.py

@@ -2,7 +2,7 @@ import unittest
 from datetime import datetime, timezone
 
 from coordinator_node.entities.model import Model
-from coordinator_node.entities.prediction import PredictionRecord
+from coordinator_node.entities.prediction import InputRecord, PredictionRecord
 from coordinator_node.contracts import CrunchContract
 from coordinator_node.services.realtime_predict import RealtimePredictService
 
@@ -111,16 +111,33 @@ class InMemoryPredictionRepository:
         ]
 
 
+class InMemoryInputRepository:
+    def __init__(self):
+        self.records: list[InputRecord] = []
+
+    def save(self, record: InputRecord):
+        for i, r in enumerate(self.records):
+            if r.id == record.id:
+                self.records[i] = record
+                return
+        self.records.append(record)
+
+    def find(self, **kwargs):
+        return list(self.records)
+
+
 class NoConfigPredictionRepository(InMemoryPredictionRepository):
     def fetch_active_configs(self):
         return []
 
 
-def _make_service(feed_reader=None, prediction_repo=None, runner=None, contract=None):
+def _make_service(feed_reader=None, prediction_repo=None, input_repo=None,
+                  runner=None, contract=None):
     return RealtimePredictService(
         checkpoint_interval_seconds=60,
         feed_reader=feed_reader or FakeFeedReader(),
         contract=contract or CrunchContract(),
+        input_repository=input_repo,
         model_repository=InMemoryModelRepository(),
         prediction_repository=prediction_repo or InMemoryPredictionRepository(),
         runner=runner or FakeRunner(),
@@ -191,5 +208,52 @@ class TestRealtimePredictService(unittest.IsolatedAsyncioTestCase):
         self.assertTrue(any("INFERENCE_OUTPUT_VALIDATION_ERROR" in line for line in logs.output))
 
 
+    async def test_run_once_sets_input_scope_with_feed_dimensions(self):
+        """Regression: input scope must include source/subject/kind/granularity
+        so the score worker can query matching feed records for ground truth."""
+        input_repo = InMemoryInputRepository()
+        pred_repo = InMemoryPredictionRepository()
+        feed_reader = FakeFeedReader({"symbol": "BTC"})
+        feed_reader.source = "binance"
+        feed_reader.subject = "BTC"
+        feed_reader.kind = "candle"
+        feed_reader.granularity = "1m"
+
+        service = _make_service(
+            feed_reader=feed_reader,
+            prediction_repo=pred_repo,
+            input_repo=input_repo,
+        )
+
+        await service.run_once(raw_input={"symbol": "BTC"}, now=datetime.now(timezone.utc))
+
+        self.assertEqual(len(input_repo.records), 1)
+        inp = input_repo.records[0]
+        # Feed dimensions must be in scope for score worker to query feed records
+        self.assertEqual(inp.scope.get("source"), "binance")
+        self.assertEqual(inp.scope.get("kind"), "candle")
+        self.assertEqual(inp.scope.get("granularity"), "1m")
+        # subject comes from config scope_template, which may override feed_reader
+        self.assertIn("subject", inp.scope)
+
+    async def test_run_once_sets_input_resolvable_at(self):
+        """Regression: input resolvable_at must be set so the score worker
+        can find inputs that are ready for ground truth resolution."""
+        input_repo = InMemoryInputRepository()
+        pred_repo = InMemoryPredictionRepository()
+        service = _make_service(
+            prediction_repo=pred_repo,
+            input_repo=input_repo,
+        )
+
+        now = datetime.now(timezone.utc)
+        await service.run_once(raw_input={"symbol": "BTC"}, now=now)
+
+        self.assertEqual(len(input_repo.records), 1)
+        inp = input_repo.records[0]
+        self.assertIsNotNone(inp.resolvable_at)
+        self.assertGreater(inp.resolvable_at, now)
+
+
 if __name__ == "__main__":
     unittest.main()

coordinator_node-0.1.4/tests/test_node_template_repositories.py

@@ -0,0 +1,86 @@
+import inspect
+import unittest
+
+from coordinator_node.db.repositories import (
+    DBInputRepository,
+    DBLeaderboardRepository,
+    DBModelRepository,
+    DBPredictionRepository,
+    DBScoreRepository,
+)
+
+
+class TestRepositoryAPIs(unittest.TestCase):
+    def test_model_repository_has_required_methods(self):
+        self.assertTrue(callable(getattr(DBModelRepository, "fetch_all", None)))
+        self.assertTrue(callable(getattr(DBModelRepository, "save", None)))
+
+    def test_input_repository_has_required_methods(self):
+        self.assertTrue(callable(getattr(DBInputRepository, "save", None)))
+        self.assertTrue(callable(getattr(DBInputRepository, "find", None)))
+
+    def test_prediction_repository_has_required_methods(self):
+        self.assertTrue(callable(getattr(DBPredictionRepository, "save", None)))
+        self.assertTrue(callable(getattr(DBPredictionRepository, "save_all", None)))
+        self.assertTrue(callable(getattr(DBPredictionRepository, "find", None)))
+
+    def test_score_repository_has_required_methods(self):
+        self.assertTrue(callable(getattr(DBScoreRepository, "save", None)))
+        self.assertTrue(callable(getattr(DBScoreRepository, "find", None)))
+
+    def test_prediction_repository_has_query_scores_method(self):
+        self.assertTrue(callable(getattr(DBPredictionRepository, "query_scores", None)))
+
+    def test_leaderboard_repository_has_required_methods(self):
+        self.assertTrue(callable(getattr(DBLeaderboardRepository, "save", None)))
+        self.assertTrue(callable(getattr(DBLeaderboardRepository, "get_latest", None)))
+
+    def test_input_repository_save_updates_scope_and_resolvable_at(self):
+        """Regression: DBInputRepository.save() must update scope_jsonb and
+        resolvable_at on existing records, not just status/actuals/meta."""
+        source = inspect.getsource(DBInputRepository.save)
+        self.assertIn("scope_jsonb", source,
+                       "save() must update scope_jsonb on existing records")
+        self.assertIn("resolvable_at", source,
+                       "save() must update resolvable_at on existing records")
+
+    def test_prediction_repository_save_updates_resolvable_at(self):
+        """Regression: DBPredictionRepository.save() must update resolvable_at
+        on existing records."""
+        source = inspect.getsource(DBPredictionRepository.save)
+        self.assertIn("existing.resolvable_at", source,
+                       "save() must update resolvable_at on existing records")
+
+    def test_all_repository_save_methods_update_all_constructor_fields(self):
+        """Regression: every save() method must update all fields it constructs,
+        except the primary key (id). Catches field omission bugs like the
+        scope_jsonb/resolvable_at issue."""
+        import re
+        from coordinator_node.db.repositories import (
+            DBCheckpointRepository, DBSnapshotRepository,
+        )
+        repos = [
+            ("DBModelRepository", DBModelRepository),
+            ("DBInputRepository", DBInputRepository),
+            ("DBPredictionRepository", DBPredictionRepository),
+            ("DBScoreRepository", DBScoreRepository),
+            ("DBSnapshotRepository", DBSnapshotRepository),
+            ("DBCheckpointRepository", DBCheckpointRepository),
+        ]
+        for name, cls in repos:
+            source = inspect.getsource(cls.save)
+            # Fields assigned via row.X in constructor
+            row_fields = set(re.findall(r'(\w+)=row\.(\w+)', source))
+            constructor_fields = {f[0] for f in row_fields if f[0] != 'id'}
+            # Fields updated via existing.X = row.X
+            existing_fields = set(re.findall(r'existing\.(\w+)\s*=\s*row\.(\w+)', source))
+            update_fields = {f[0] for f in existing_fields}
+
+            missing = constructor_fields - update_fields
+            self.assertEqual(missing, set(),
+                             f"{name}.save() creates fields {sorted(missing)} "
+                             f"but doesn't update them on existing records")
+
+
+if __name__ == "__main__":
+    unittest.main()

{coordinator_node-0.1.2 → coordinator_node-0.1.4}/uv.lock

@@ -304,7 +304,7 @@ wheels = [
 
 [[package]]
 name = "coordinator-node"
-version = "0.1.1"
+version = "0.1.3"
 source = { editable = "." }
 dependencies = [
     { name = "fastapi" },

coordinator_node-0.1.2/tests/test_node_template_repositories.py

@@ -1,39 +0,0 @@
-import unittest
-
-from coordinator_node.db.repositories import (
-    DBInputRepository,
-    DBLeaderboardRepository,
-    DBModelRepository,
-    DBPredictionRepository,
-    DBScoreRepository,
-)
-
-
-class TestRepositoryAPIs(unittest.TestCase):
-    def test_model_repository_has_required_methods(self):
-        self.assertTrue(callable(getattr(DBModelRepository, "fetch_all", None)))
-        self.assertTrue(callable(getattr(DBModelRepository, "save", None)))
-
-    def test_input_repository_has_required_methods(self):
-        self.assertTrue(callable(getattr(DBInputRepository, "save", None)))
-        self.assertTrue(callable(getattr(DBInputRepository, "find", None)))
-
-    def test_prediction_repository_has_required_methods(self):
-        self.assertTrue(callable(getattr(DBPredictionRepository, "save", None)))
-        self.assertTrue(callable(getattr(DBPredictionRepository, "save_all", None)))
-        self.assertTrue(callable(getattr(DBPredictionRepository, "find", None)))
-
-    def test_score_repository_has_required_methods(self):
-        self.assertTrue(callable(getattr(DBScoreRepository, "save", None)))
-        self.assertTrue(callable(getattr(DBScoreRepository, "find", None)))
-
-    def test_prediction_repository_has_query_scores_method(self):
-        self.assertTrue(callable(getattr(DBPredictionRepository, "query_scores", None)))
-
-    def test_leaderboard_repository_has_required_methods(self):
-        self.assertTrue(callable(getattr(DBLeaderboardRepository, "save", None)))
-        self.assertTrue(callable(getattr(DBLeaderboardRepository, "get_latest", None)))
-
-
-if __name__ == "__main__":
-    unittest.main()