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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: coordinator-node
-Version: 0.1.2
+Version: 0.1.3
 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.3}/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.3
 RUN pip install --no-cache-dir "coordinator-node>=${COORDINATOR_NODE_VERSION}"
 
 # Challenge package

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

@@ -62,7 +62,7 @@ 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:
@@ -93,7 +93,7 @@ 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:
@@ -124,7 +124,7 @@ 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:
@@ -148,7 +148,7 @@ 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:
@@ -171,7 +171,7 @@ 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:

{coordinator_node-0.1.2 → coordinator_node-0.1.3}/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.3}/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.3}/coordinator_node/workers/report_worker.py

@@ -667,6 +667,94 @@ def get_checkpoint_emission_cli_format(
     }
 
 
+@app.get("/reports/checkpoints/{checkpoint_id}/prizes")
+def get_checkpoint_prizes(
+    checkpoint_id: str,
+    checkpoint_repo: Annotated[DBCheckpointRepository, Depends(get_checkpoint_repository)],
+    total_prize: Annotated[int, Query(description="Total prize pool to distribute (in token lowest denomination)")] = 0,
+) -> list[dict[str, Any]]:
+    """Return checkpoint emission as Prize[] JSON for the coordinator webapp.
+
+    The webapp's CreateCheckpoint UI expects:
+      [{prizeId, timestamp, model, prize}]
+    where `model` is a model ID and `prize` is an absolute token amount.
+
+    This endpoint converts the node's frac64 percentage-based emission into
+    the webapp format by distributing `total_prize` proportionally.
+    """
+    checkpoints = checkpoint_repo.find()
+    checkpoint = next((c for c in checkpoints if c.id == checkpoint_id), None)
+    if checkpoint is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="Checkpoint not found")
+    if not checkpoint.entries:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="No emission data in checkpoint")
+
+    emission = checkpoint.entries[0]
+    ranking = checkpoint.meta.get("ranking", [])
+    frac64_multiplier = 1_000_000_000
+    timestamp = int(checkpoint.period_end.timestamp())
+
+    prizes: list[dict[str, Any]] = []
+    for reward in emission.get("cruncher_rewards", []):
+        idx = reward["cruncher_index"]
+        pct = reward["reward_pct"] / frac64_multiplier
+        model_id = ranking[idx]["model_id"] if idx < len(ranking) else str(idx)
+
+        prize_amount = int(round(total_prize * pct))
+        prizes.append({
+            "prizeId": f"{checkpoint_id}-{model_id}",
+            "timestamp": timestamp,
+            "model": model_id,
+            "prize": prize_amount,
+        })
+
+    return prizes
+
+
+@app.get("/reports/checkpoints/latest/prizes")
+def get_latest_checkpoint_prizes(
+    checkpoint_repo: Annotated[DBCheckpointRepository, Depends(get_checkpoint_repository)],
+    total_prize: Annotated[int, Query(description="Total prize pool to distribute (in token lowest denomination)")] = 0,
+) -> dict[str, Any]:
+    """Return the latest checkpoint's prizes in webapp format.
+
+    Convenience wrapper that finds the latest checkpoint and returns its prizes.
+    """
+    checkpoint = checkpoint_repo.get_latest()
+    if checkpoint is None:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="No checkpoints found")
+    if not checkpoint.entries:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail="No emission data in checkpoint")
+
+    emission = checkpoint.entries[0]
+    ranking = checkpoint.meta.get("ranking", [])
+    frac64_multiplier = 1_000_000_000
+    timestamp = int(checkpoint.period_end.timestamp())
+
+    prizes: list[dict[str, Any]] = []
+    for reward in emission.get("cruncher_rewards", []):
+        idx = reward["cruncher_index"]
+        pct = reward["reward_pct"] / frac64_multiplier
+        model_id = ranking[idx]["model_id"] if idx < len(ranking) else str(idx)
+
+        prize_amount = int(round(total_prize * pct))
+        prizes.append({
+            "prizeId": f"{checkpoint.id}-{model_id}",
+            "timestamp": timestamp,
+            "model": model_id,
+            "prize": prize_amount,
+        })
+
+    return {
+        "checkpoint_id": checkpoint.id,
+        "status": checkpoint.status,
+        "period_start": checkpoint.period_start.isoformat(),
+        "period_end": checkpoint.period_end.isoformat(),
+        "total_prize": total_prize,
+        "prizes": prizes,
+    }
+
+
 @app.get("/reports/emissions/latest")
 def get_latest_emission(
     checkpoint_repo: Annotated[DBCheckpointRepository, Depends(get_checkpoint_repository)],

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

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

{coordinator_node-0.1.2 → coordinator_node-0.1.3}/tests/test_checkpoint_worker.py

@@ -397,5 +397,97 @@ class TestEmissionEndpoints(unittest.TestCase):
         self.assertEqual(result["emission"]["crunch"], "crunch_abc")
 
 
+# ── Prizes endpoint tests ──
+
+
+class TestPrizesEndpoints(unittest.TestCase):
+    def _make_checkpoint(self) -> CheckpointRecord:
+        return CheckpointRecord(
+            id="CKP_001",
+            period_start=now - timedelta(days=7),
+            period_end=now,
+            status=CheckpointStatus.PENDING,
+            entries=[{
+                "crunch": "crunch_abc",
+                "cruncher_rewards": [
+                    {"cruncher_index": 0, "reward_pct": 600_000_000},
+                    {"cruncher_index": 1, "reward_pct": 400_000_000},
+                ],
+                "compute_provider_rewards": [],
+                "data_provider_rewards": [],
+            }],
+            meta={"ranking": [
+                {"model_id": "m1", "rank": 1},
+                {"model_id": "m2", "rank": 2},
+            ]},
+            created_at=now,
+        )
+
+    def test_get_checkpoint_prizes_format(self):
+        from coordinator_node.workers.report_worker import get_checkpoint_prizes
+
+        repo = MemCheckpointRepository([self._make_checkpoint()])
+        result = get_checkpoint_prizes("CKP_001", repo, total_prize=1_000_000)
+
+        self.assertEqual(len(result), 2)
+        # First model gets 60%
+        self.assertEqual(result[0]["model"], "m1")
+        self.assertEqual(result[0]["prize"], 600_000)
+        self.assertEqual(result[0]["prizeId"], "CKP_001-m1")
+        self.assertIn("timestamp", result[0])
+        # Second model gets 40%
+        self.assertEqual(result[1]["model"], "m2")
+        self.assertEqual(result[1]["prize"], 400_000)
+
+    def test_get_checkpoint_prizes_zero_total(self):
+        from coordinator_node.workers.report_worker import get_checkpoint_prizes
+
+        repo = MemCheckpointRepository([self._make_checkpoint()])
+        result = get_checkpoint_prizes("CKP_001", repo, total_prize=0)
+
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]["prize"], 0)
+        self.assertEqual(result[1]["prize"], 0)
+
+    def test_get_checkpoint_prizes_not_found(self):
+        from coordinator_node.workers.report_worker import get_checkpoint_prizes
+        from fastapi import HTTPException
+
+        repo = MemCheckpointRepository()
+        with self.assertRaises(HTTPException):
+            get_checkpoint_prizes("CKP_NONEXISTENT", repo, total_prize=1000)
+
+    def test_get_checkpoint_prizes_sums_to_total(self):
+        from coordinator_node.workers.report_worker import get_checkpoint_prizes
+
+        repo = MemCheckpointRepository([self._make_checkpoint()])
+        total = 999_999
+        result = get_checkpoint_prizes("CKP_001", repo, total_prize=total)
+
+        actual_sum = sum(p["prize"] for p in result)
+        # May differ by ±1 due to rounding, but should be close
+        self.assertAlmostEqual(actual_sum, total, delta=len(result))
+
+    def test_get_latest_checkpoint_prizes(self):
+        from coordinator_node.workers.report_worker import get_latest_checkpoint_prizes
+
+        repo = MemCheckpointRepository([self._make_checkpoint()])
+        result = get_latest_checkpoint_prizes(repo, total_prize=1_000_000)
+
+        self.assertEqual(result["checkpoint_id"], "CKP_001")
+        self.assertEqual(result["total_prize"], 1_000_000)
+        self.assertEqual(len(result["prizes"]), 2)
+        self.assertEqual(result["prizes"][0]["model"], "m1")
+        self.assertEqual(result["prizes"][0]["prize"], 600_000)
+
+    def test_get_latest_checkpoint_prizes_not_found(self):
+        from coordinator_node.workers.report_worker import get_latest_checkpoint_prizes
+        from fastapi import HTTPException
+
+        repo = MemCheckpointRepository()
+        with self.assertRaises(HTTPException):
+            get_latest_checkpoint_prizes(repo, total_prize=1000)
+
+
 if __name__ == "__main__":
     unittest.main()

{coordinator_node-0.1.2 → coordinator_node-0.1.3}/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.3/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.3}/uv.lock

@@ -304,7 +304,7 @@ wheels = [
 
 [[package]]
 name = "coordinator-node"
-version = "0.1.1"
+version = "0.1.2"
 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()