gridlinegpu 0.1.6__tar.gz → 0.1.8__tar.gz

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridlinegpu
-Version: 0.1.6
+Version: 0.1.8
 Summary: Python client for Gridline YAML workload routing
 Author: Gridline GPU
 License: Proprietary
@@ -140,7 +140,7 @@ top-up or payment step in the SDK. Install the source extra and turn the beta on
 shell:
 
 ```sh
-python -m pip install 'gridlinegpu[source-contract]>=0.1.6,<0.2'
+python -m pip install 'gridlinegpu[source-contract]>=0.1.7,<0.2'
 export GRIDLINE_SOURCE_SDK_ENABLED=true
 gridline setup --apply   # once: saves a private, scoped token file
 ```
@@ -213,6 +213,8 @@ print(job.report()["settlement"])  # reserved, held, charged and released credit
 ```
 
 `job.status()` reads the current state without waiting, and `job.cancel()` requests a stop.
+`job.isolation_tier()` names the isolation tier the job's code ran under (`kernel_cgroup` or
+`hardened_user_separation`, see the security page), or `None` before a machine is allocated.
 `client.history(limit=20)` lists your recent jobs, newest first. `report()` and `history()`
 raise `report_unavailable` / `history_unavailable` until those reads are switched on for
 the beta; the job itself is unaffected. A complete minimal

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/README.md

@@ -122,7 +122,7 @@ top-up or payment step in the SDK. Install the source extra and turn the beta on
 shell:
 
 ```sh
-python -m pip install 'gridlinegpu[source-contract]>=0.1.6,<0.2'
+python -m pip install 'gridlinegpu[source-contract]>=0.1.7,<0.2'
 export GRIDLINE_SOURCE_SDK_ENABLED=true
 gridline setup --apply   # once: saves a private, scoped token file
 ```
@@ -195,6 +195,8 @@ print(job.report()["settlement"])  # reserved, held, charged and released credit
 ```
 
 `job.status()` reads the current state without waiting, and `job.cancel()` requests a stop.
+`job.isolation_tier()` names the isolation tier the job's code ran under (`kernel_cgroup` or
+`hardened_user_separation`, see the security page), or `None` before a machine is allocated.
 `client.history(limit=20)` lists your recent jobs, newest first. `report()` and `history()`
 raise `report_unavailable` / `history_unavailable` until those reads are switched on for
 the beta; the job itself is unaffected. A complete minimal

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "gridlinegpu"
-version = "0.1.6"
+version = "0.1.8"
 description = "Python client for Gridline YAML workload routing"
 readme = "README.md"
 requires-python = ">=3.10"

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/src/gridlinegpu/_source_contract.py

@@ -253,7 +253,7 @@ SOURCE_CURATED_ACTIVATION_PRECONDITIONS = MappingProxyType({
 # The models: capability word; off by default (a code constant), as in versions.ts. Off, the
 # registry is the v2.1 and v2.3 tuples and every check answers as before.
 SOURCE_MODELS_CAPABILITY = "models_hf_v1"
-SOURCE_MODELS_HF_V1_ENABLED = False
+SOURCE_MODELS_HF_V1_ENABLED = True
 # versions.ts SOURCE_MODELS_ACTIVATION_PRECONDITIONS: blocking 2h-2 items, each false until landed
 # (capture and frame refuse captured files under models/ first, compared case-folded).
 SOURCE_MODELS_ACTIVATION_PRECONDITIONS = MappingProxyType({
@@ -271,11 +271,11 @@ SOURCE_MODELS_ACTIVATION_PRECONDITIONS = MappingProxyType({
     "registerPublished": True,
     # MR-1: the manifest ledger, quota, retention and purge (source_runtime_manifests).
     "manifestRetention": True,
-    "hubContractRecorded": False, "imageAllowanceRegistered": True,
+    "hubContractRecorded": True, "imageAllowanceRegistered": True,
     # AR-1: the supervisor refuses app_root_unsafe for a payload-writable app root (models staged).
     "appRootOwnership": True,
     # Command (MA-2 ruling 1): launcher.ts SOURCE_LAUNCHER_HUB_CDN_HOSTS_ENABLED (off).
-    "hubCdnHostsEnabled": False,
+    "hubCdnHostsEnabled": True,
 })
 # versions.ts SOURCE_MODELS_HARDENING_ITEMS (Command, MA-2): tracked, never gating activation.
 SOURCE_MODELS_HARDENING_ITEMS = MappingProxyType({"executionReadOnlyMount": False})

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/src/gridlinegpu/_source_interfaces.py

@@ -603,7 +603,7 @@ def validate_source_job_status(value):
 # Status v3 (job.ts): v2 plus the current task's stage, a coarse packaging step and the failure
 # envelope. failureCode, error.stage and error.code are open words (H6): a newer server's code
 # or stage is accepted and arrives with its own text. Structural vocabularies stay closed.
-SOURCE_JOB_STATUS_VERSIONS = (2, 3, 4, 5, 6, 7)
+SOURCE_JOB_STATUS_VERSIONS = (2, 3, 4, 5, 6, 7, 8)
 SOURCE_JOB_TASK_STAGES = ("runtime_resolution", "runtime_packaging", "compute_routing")
 SOURCE_JOB_PACKAGING_STEPS = ("dependencies", "wheels", "image", "qualification", "handoff")
 _open_word = _pattern(r"[a-z_]{1,64}")
@@ -1244,10 +1244,38 @@ def validate_source_job_status_v7(value):
     return value
 
 
+# Status v8 (job.ts, O6-C PR-D): v7 plus the run's isolation tier. The shared vectors are
+# job-status-v8.json.
+SOURCE_JOB_ISOLATION_TIERS = ("kernel_cgroup", "hardened_user_separation", "user_separation")
+SOURCE_JOB_STATUS_V8_FIELDS = SOURCE_JOB_STATUS_V7_FIELDS + ("isolationTier",)
+_JOB_STATUS_V8 = {
+    **_JOB_STATUS_V7,
+    "schemaVersion": _number_literal(8),
+    "isolationTier": _nullable(_one_of(*SOURCE_JOB_ISOLATION_TIERS)),
+}
+
+
+def validate_source_job_status_v8(value):
+    """GET /jobs/{jobId}?schemaVersion=8: v7 plus ``isolationTier``, at most 64 KiB (job.ts
+    sourceJobStatusV8Schema). ``isolationTier`` is the isolation tier of the machine the job's
+    code ran on: ``kernel_cgroup``, ``hardened_user_separation`` (the disclosed hardened tier,
+    see the security page) or ``user_separation`` (the owner canary only); null before such a
+    machine. Never a location, SKU or resource id."""
+    _require(value, _JOB_STATUS_V8, "jobStatus")
+    _status_v6_rules(value)
+    attempts = value["launchAttempts"]
+    if attempts is not None and (
+            attempts["refusals"] > attempts["attempt"]
+            or (attempts["lastRefusal"] is None) != (attempts["refusals"] == 0)):
+        _record_fail("jobStatus.launchAttempts")
+    _bounded(value, SOURCE_JOB_LIMITS["statusBytes"], "jobStatus")
+    return value
+
+
 def validate_source_job_status_answer(value):
-    """A status answer of any version this SDK reads (2 to 7), chosen by its schemaVersion. A
-    server that does not serve v7, v6, v5, v4 or v3 (older, or switched off) answers the highest
-    it serves; v2 to v5 stay readable for jobs without Step 10 facts (the server refuses them for
+    """A status answer of any version this SDK reads (2 to 8), chosen by its schemaVersion. A
+    server that does not serve v8, v7, v6, v5, v4 or v3 (older, or switched off) answers the
+    highest it serves; v2 to v5 stay readable for jobs without Step 10 facts (the server refuses them for
     a job with a Step 10 outcome or execution state: status_version_unsupported)."""
     version = value.get("schemaVersion") if type(value) is dict else None
     if _number_literal(2)(version):
@@ -1262,6 +1290,8 @@ def validate_source_job_status_answer(value):
         return validate_source_job_status_v6(value)
     if _number_literal(7)(version):
         return validate_source_job_status_v7(value)
+    if _number_literal(8)(version):
+        return validate_source_job_status_v8(value)
     _record_fail("jobStatus.schemaVersion")
 
 

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/src/gridlinegpu/_source_job.py

@@ -5,10 +5,12 @@ SDK gate is on; it is off by default.
 - The fields are the receipt's (spec 5.2), snake-cased. The receipt is historical: status
   may already have advanced past ``initial_phase``.
 - ``status()`` reads the current bounded status (spec 5.2/5.7); it writes nothing. It asks
-  for status v7 (credits S4b: v6 plus ``launchAttempts``) and also accepts v6, v5, v4, v3 or
-  v2, which an older server or a switched-off v7 (or v6, v5, v4, v3) answers; a server refuses
+  for status v8 (O6-C PR-D: v7 plus ``isolationTier``) and also accepts v7 (credits S4b: v6
+  plus ``launchAttempts``), v6, v5, v4, v3 or v2, which an older server or a switched-off v8
+  (or v7, v6, v5, v4, v3) answers; a server refuses
   v2-v5 for a job with a Step 10 outcome (``status_version_unsupported``). ``route()`` returns
-  the v4-v7 route summary (spec 8.6), or None.
+  the v4-v8 route summary (spec 8.6), or None. ``isolation_tier()`` returns the v8 tier of the
+  machine the code ran on, or None (before one, or from an older answer).
 - ``funding_action()`` returns the server-owned Add funds action (status v5, spec 9.3), or
   None; ``recheck_funding()`` sends exactly that action's binding back to ask for one bounded
   recheck of the provider's funds. Neither starts a payment; the customer pays on the
@@ -60,8 +62,8 @@ from .errors import WaitTimeout
 
 _JOBS = "/api/v2/source/jobs/"
 _JOB_ID = re.compile(r"job_[a-f0-9]{32}")
-# Status version asked for; the answer's schemaVersion (2 to 7) names the shape served.
-_STATUS_VERSION = 7
+# Status version asked for; the answer's schemaVersion (2 to 8) names the shape served.
+_STATUS_VERSION = 8
 # Asked once more after an answer of HTTP 500: v3 reads no route plan, launch row or Step 10
 # record, so a server failure confined to those projections never makes status (or wait)
 # unavailable (8-ix, 9-xii). A Step 10 job refuses v3 (S10-R16): the 500 then stands.
@@ -220,7 +222,8 @@ class JobHandle:
     def status(self):
         """Current owner-authorized job status, bound to this job and its immutable receipt.
 
-        Returns the validated answer as served: v6 (v5 with ``financial`` replaced by
+        Returns the validated answer as served: v8 (v7 plus ``isolationTier``; see
+        ``isolation_tier()``), v7 (v6 plus ``launchAttempts``), v6 (v5 with ``financial`` replaced by
         ``cost``, plus the Step 10 ``execution``, ``result``, ``logs`` and ``reminder`` blocks),
         v5 (v4 plus the launch phases, the ``provider_launch`` or ``execution`` task,
         ``cleanup``, ``financial`` and the funding action; see ``funding_action()``), v4 (v3
@@ -239,6 +242,17 @@ class JobHandle:
         """
         return _read_status(self._client, self.job_id, self._fail, self.receipt())
 
+    def isolation_tier(self):
+        """The isolation tier of the machine this job's code ran on (status v8), or None.
+
+        Reads status exactly as ``status()`` does (same errors) and returns ``"kernel_cgroup"``,
+        ``"hardened_user_separation"`` (the disclosed hardened tier: per-process memory and
+        file-size limits and a sampled memory check; see the security page) or
+        ``"user_separation"`` (the owner canary only). None before such a machine, and from a
+        server that answers v7 or older.
+        """
+        return self.status().get("isolationTier")
+
     def funding_action(self):
         """The job's current Add funds action (status v5, spec 9.3 L1721), or None.
 
@@ -455,12 +469,12 @@ def _job_handle(receipt, client):
 
 
 def _read_status(client, job_id, fail, receipt=None):
-    """The job's validated status, asked as v7 (once more as v3 after a 500), bound to the job
+    """The job's validated status, asked as v8 (once more as v3 after a 500), bound to the job
     (and to its receipt when known)."""
     status, headers, data = _request_status(client, job_id, fail, _STATUS_VERSION)
     if status == 500:
         fallback = _request_status(client, job_id, fail, _FALLBACK_STATUS_VERSION)
-        # A Step 10 job refuses v3 (S10-R16): the v7 failure stays an unavailable read.
+        # A Step 10 job refuses v3 (S10-R16): the v8 failure stays an unavailable read.
         if not (fallback[0] == 409 and _error_code(fallback[2]) == "status_version_unsupported"):
             status, headers, data = fallback
     if status == 200:

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/src/gridlinegpu/_source_release.py

@@ -72,5 +72,5 @@ def sdk_surface_digest(bounds=None):
 # RECORD content digest plus the candidate SHA).
 SOURCE_RELEASE_COMPATIBILITY = {
     "contract": SOURCE_RELEASE_CONFIG_CONTRACT,
-    "surfaces": {"sdk": "ad9e2daf472c76affddd93a36aabe19f7686b0394a953345ffae931201efedae"},
+    "surfaces": {"sdk": "2d6b1bd3408b61f57f788f3e68d502cdb1626c1bf0f486b4dfefc5dc9bd47f24"},
 }

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/src/gridlinegpu.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gridlinegpu
-Version: 0.1.6
+Version: 0.1.8
 Summary: Python client for Gridline YAML workload routing
 Author: Gridline GPU
 License: Proprietary
@@ -140,7 +140,7 @@ top-up or payment step in the SDK. Install the source extra and turn the beta on
 shell:
 
 ```sh
-python -m pip install 'gridlinegpu[source-contract]>=0.1.6,<0.2'
+python -m pip install 'gridlinegpu[source-contract]>=0.1.7,<0.2'
 export GRIDLINE_SOURCE_SDK_ENABLED=true
 gridline setup --apply   # once: saves a private, scoped token file
 ```
@@ -213,6 +213,8 @@ print(job.report()["settlement"])  # reserved, held, charged and released credit
 ```
 
 `job.status()` reads the current state without waiting, and `job.cancel()` requests a stop.
+`job.isolation_tier()` names the isolation tier the job's code ran under (`kernel_cgroup` or
+`hardened_user_separation`, see the security page), or `None` before a machine is allocated.
 `client.history(limit=20)` lists your recent jobs, newest first. `report()` and `history()`
 raise `report_unavailable` / `history_unavailable` until those reads are switched on for
 the beta; the job itself is unaffected. A complete minimal

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/tests/test_client_source.py

@@ -531,7 +531,7 @@ class ClientJobTests(ClientSourceTestCase):
         self.assertEqual((status["schemaVersion"], status["phase"], status["outcome"]),
                          (3, "terminal", "cancelled"))
         self.assertIsNone(status["error"])
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7")] * 2)
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8")] * 2)
         terminal = job_status_v3(self.server.job, "terminal")
         _, reason, action = describe("build_failed")
         failed = {**terminal, "outcome": "failed", "failureCode": "build_failed",

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/tests/test_source_contract.py

@@ -44,7 +44,7 @@ from gridlinegpu._source_interfaces import (
     validate_source_admission_receipt, validate_source_admission_request, validate_source_funding_recheck_answer,
     validate_source_job_status, validate_source_job_status_answer, validate_source_job_status_v3,
     validate_source_job_status_v4, validate_source_job_status_v5, validate_source_job_status_v6,
-    validate_source_job_status_v7,
+    validate_source_job_status_v7, validate_source_job_status_v8,
     validate_source_job_stop_acknowledgement,
     validate_source_preflight_response, validate_source_preparation_envelope, validate_source_preparation_receipt,
     validate_source_verified_set,
@@ -602,7 +602,7 @@ class SourceInterfaceTests(unittest.TestCase):
 
     def test_status_answers_dispatch_on_their_version(self):
         answers = fixtures("interfaces.json")["answers"]
-        self.assertEqual(SOURCE_JOB_STATUS_VERSIONS, (2, 3, 4, 5, 6, 7))
+        self.assertEqual(SOURCE_JOB_STATUS_VERSIONS, (2, 3, 4, 5, 6, 7, 8))
         for name in ("jobStatus", "jobStatusV3"):
             for case in answers[name]["valid"]:
                 with self.subTest(answer=name, case=case["name"]):
@@ -614,7 +614,7 @@ class SourceInterfaceTests(unittest.TestCase):
                         validate_source_job_status_answer(case["value"])
         v3 = answers["jobStatusV3"]["valid"][0]["value"]
         without = {key: item for key, item in v3.items() if key != "schemaVersion"}
-        wrong = [{**v3, "schemaVersion": version} for version in (1, 8, "3", "4", True, None, 2.5)]
+        wrong = [{**v3, "schemaVersion": version} for version in (1, 9, "3", "4", True, None, 2.5)]
         for value in wrong + [without, [], "3", None]:
             with self.subTest(value=repr(value)[:40]):
                 with self.assertRaises(SourceRecordError) as caught:
@@ -865,6 +865,38 @@ class SourceInterfaceTests(unittest.TestCase):
         with self.assertRaises(SourceRecordError):
             validate_source_job_status_v7({**status_v6_answer({}), "schemaVersion": 7})
 
+    def test_shared_status_v8_vectors(self):
+        # O6-C PR-D parity with job.ts sourceJobStatusV8Schema: v7 plus isolationTier.
+        from gridlinegpu import _source_interfaces as interfaces
+        vectors = fixtures("job-status-v8.json")
+        self.assertEqual(vectors["contract"], "gridline-source-job-status-v8-fixtures-v1")
+
+        def v8(patch):
+            return status_v6_answer(patch, "job-status-v8.json")
+
+        answers = vectors["answers"]
+        self.assertTrue(answers["valid"] and answers["invalid"])
+        for name, patch in answers["valid"]:
+            with self.subTest(case=name):
+                value = v8(patch)
+                self.assertIs(validate_source_job_status_v8(value), value)
+                self.assertIs(validate_source_job_status_answer(value), value)
+        for name, patch, path in answers["invalid"]:
+            with self.subTest(case=name):
+                with self.assertRaises(SourceRecordError) as caught:
+                    validate_source_job_status_v8(v8(patch))
+                self.assertEqual(caught.exception.code, "schema_invalid")
+                with self.assertRaises(SourceRecordError):
+                    validate_source_job_status_answer(v8(patch))
+        self.assertEqual(interfaces.SOURCE_JOB_STATUS_V8_FIELDS, tuple(vectors["fields"]))
+        self.assertEqual(list(v8({})), vectors["fields"])
+        self.assertEqual(list(interfaces.SOURCE_JOB_ISOLATION_TIERS), vectors["vocabularies"]["isolationTiers"])
+        # A v8 answer is never a v7 answer, and the reverse.
+        with self.assertRaises(SourceRecordError):
+            validate_source_job_status_v7({**v8({}), "schemaVersion": 7})
+        with self.assertRaises(SourceRecordError):
+            validate_source_job_status_v8({**status_v6_answer({}, "job-status-v7.json"), "schemaVersion": 8})
+
     def test_funding_surfaces_match_the_shared_vectors(self):
         vectors = fixtures("job-status-v5.json")
         billing = vectors["billing"]
@@ -1011,7 +1043,8 @@ class SourceInterfaceTests(unittest.TestCase):
         self.assertEqual(source_models_activation_missing(), missing)
         # The activation checker: off passes; on passes only with every precondition true.
         self.assertTrue(source_models_activation_allowed(False))
-        self.assertFalse(source_models_activation_allowed(True))
+        # On passes exactly when every precondition has landed (C1 landed hubContractRecorded).
+        self.assertIs(source_models_activation_allowed(True), not missing)
         landed = {name: True for name in SOURCE_MODELS_ACTIVATION_PRECONDITIONS}
         self.assertTrue(source_models_activation_allowed(True, landed))
         for name in SOURCE_MODELS_ACTIVATION_PRECONDITIONS:
@@ -1106,17 +1139,22 @@ class SourceInterfaceTests(unittest.TestCase):
                          vectors["enabled"])
         self.assertEqual(json.loads(json.dumps(dict(SOURCE_CURATED_MODELS_VERSION_TUPLE))), vectors["tuple"])
         self.assertIn(SOURCE_CURATED_MODELS_VERSION_TUPLE, SOURCE_REGISTERED_VERSION_TUPLES)
-        self.assertNotIn(SOURCE_CURATED_MODELS_VERSION_TUPLE, SOURCE_VERSION_TUPLES)
+        # Production holds v2.7 exactly while both capabilities are on (the models activation).
+        both = SOURCE_CURATED_RUNTIMES_ENABLED and SOURCE_MODELS_HF_V1_ENABLED
+        self.assertIs(SOURCE_CURATED_MODELS_VERSION_TUPLE in SOURCE_VERSION_TUPLES, both)
         for case in vectors["tuples"]:
             with self.subTest(case=case["name"]):
                 self.assertEqual(check_source_version_tuple(case["tuple"], SOURCE_REGISTERED_VERSION_TUPLES),
                                  case["expected"])
-                self.assertEqual(check_source_version_tuple(case["tuple"]), case["expectedProduction"])
+                production = case.get("expectedProductionOn", case["expectedProduction"]) if both \
+                    else case["expectedProduction"]
+                self.assertEqual(check_source_version_tuple(case["tuple"]), production)
         for case in vectors["offers"]:
             with self.subTest(offer=case["name"]):
                 self.assertEqual(source_curated_models_offered(case["capabilities"], case["curated"], case["models"]),
                                  case["offered"])
-                self.assertFalse(source_curated_models_offered(case["capabilities"]))
+                self.assertEqual(source_curated_models_offered(case["capabilities"]),
+                                 source_curated_models_offered(case["capabilities"], both, both))
 
     def test_curated_models_activation_needs_both_precondition_sets(self):
         curated = {name: True for name in SOURCE_CURATED_ACTIVATION_PRECONDITIONS}

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/tests/test_source_curated_run.py

@@ -160,9 +160,10 @@ class CuratedModelsRunTests(SourceRunTestCase):
                 with self.assertRaises(SourceSubmissionError) as caught:
                     self.authored(curated, models, preflight)
                 self.assertEqual(caught.exception.code, "curated_runtimes_unavailable")
-        # This release: both off, so a run is refused right after the preflight.
+        # A release with models off refuses a run right after the preflight.
         server = FakeSource(preflight=offering_curated_models())
-        with self.assertRaises(SourceSubmissionError):
+        with mock.patch.object(_source_contract, "SOURCE_MODELS_HF_V1_ENABLED", False), \
+                self.assertRaises(SourceSubmissionError):
             self.run_workload(server)
         self.assertEqual(self.calls(server), [PREFLIGHT])
         self.assertEqual(self.captures(), [])

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/tests/test_source_job.py

@@ -247,7 +247,7 @@ class JobHandleTests(unittest.TestCase):
         self.assertEqual(job.status(), job_status(RECEIPT))
         self.server.status_version = 3
         self.assertEqual(job.status(), job_status_v3(RECEIPT))
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7")] * 2)
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8")] * 2)
         for name, patch in fixtures("job-status-v4.json")["answers"]["valid"]:
             with self.subTest(name=name):
                 answer = status_v4_answer(patch)
@@ -299,7 +299,7 @@ class JobHandleTests(unittest.TestCase):
                 self.server.phases = [_json(200, answer)]
                 self.assertEqual(job.route(), expected)
         self.assertEqual(best_effort["route"]["estimate"], None)
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7")] * len(cases))
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8")] * len(cases))
         sunk = status_v4_answer({"route": "$route:sunkUnknown"})
         self.server.phases = [_json(200, sunk)]
         self.assertEqual(job.route()["estimate"]["totalUnknownReason"], "sunk_cost_unknown")
@@ -325,7 +325,7 @@ class JobHandleTests(unittest.TestCase):
         v3 = v3_vector("routing pending after commit")
         self.server.phases = [(500, {}, b""), _json(200, v3)]
         self.assertEqual(job.status(), v3)
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7"), ("GET", "schemaVersion=3")])
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8"), ("GET", "schemaVersion=3")])
         # route() over the fallback is None: v3 carries no route.
         self.server.phases = [(500, {}, b""), _json(200, v3)]
         self.assertIsNone(job.route())
@@ -340,13 +340,13 @@ class JobHandleTests(unittest.TestCase):
         with self.assertRaises(SourceSubmissionError) as caught:
             job.status()
         self.assertEqual((caught.exception.code, caught.exception.status), ("job_status_unavailable", 500))
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7"), ("GET", "schemaVersion=3")])
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8"), ("GET", "schemaVersion=3")])
         # Other failures are not retried as v3.
         self.server.queries.clear()
         self.server.phases = [(503, {}, b"{}")]
         with self.assertRaises(SourceSubmissionError):
             job.status()
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7")])
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8")])
 
     def test_unknown_failure_codes_and_error_stages_never_crash(self):
         # H6: failure codes and error stages are open words. A newer server's code arrives with
@@ -576,7 +576,7 @@ class JobFundingTests(unittest.TestCase):
                 expected = None if answer["fundingAction"] is None else {
                     key: answer[key] for key in ("actionRequired", "fundingAction", "billing")}
                 self.assertEqual(job.funding_action(), expected)
-        self.assertEqual(set(self.server.queries), {("GET", "schemaVersion=7")})
+        self.assertEqual(set(self.server.queries), {("GET", "schemaVersion=8")})
         # Older servers (v4, v3, v2) carry no action.
         for answer in (status_v4_answer({}), v3_vector(CLAIMED), job_status(RECEIPT)):
             self.server.phases = [_json(200, answer)]

{gridlinegpu-0.1.6 → gridlinegpu-0.1.8}/tests/test_source_job_results.py

@@ -950,7 +950,7 @@ class JobStatusV6Tests(unittest.TestCase):
                 with self.assertRaises(SourceSubmissionError) as caught:
                     job.status()
                 self.assertEqual(caught.exception.code, "remote_contract_invalid")
-        self.assertEqual(set(self.server.queries), {("GET", "schemaVersion=7")})
+        self.assertEqual(set(self.server.queries), {("GET", "schemaVersion=8")})
 
     def test_wait_returns_the_structured_result_with_separate_states(self):
         running = vector("running: started, advisory progress, result pending, no receipt yet")
@@ -1014,7 +1014,7 @@ class JobStatusV6Tests(unittest.TestCase):
         with self.assertRaises(SourceSubmissionError) as caught:
             job.status()
         self.assertEqual((caught.exception.code, caught.exception.status), ("job_status_unavailable", 500))
-        self.assertEqual(self.server.queries, [("GET", "schemaVersion=7"), ("GET", "schemaVersion=3")])
+        self.assertEqual(self.server.queries, [("GET", "schemaVersion=8"), ("GET", "schemaVersion=3")])
 
 
 class JobCostTests(unittest.TestCase):