labqoat 0.2.2__tar.gz → 0.2.4__tar.gz

{labqoat-0.2.2 → labqoat-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: labqoat
-Version: 0.2.2
+Version: 0.2.4
 Summary: Typed Python SDK and lab command-line client for the Labqoat platform
 Author: Labqoat
 License: MIT

{labqoat-0.2.2 → labqoat-0.2.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "labqoat"
-version = "0.2.2"
+version = "0.2.4"
 description = "Typed Python SDK and lab command-line client for the Labqoat platform"
 readme = "README.md"
 requires-python = ">=3.11"

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/__init__.py

@@ -21,7 +21,7 @@ from labqoat.references import (
     Sha256,
 )
 
-__version__ = "0.2.2"
+__version__ = "0.2.4"
 
 __all__ = [
     "Client",

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/base_client.py

@@ -194,7 +194,9 @@ class BaseClient:
         detail = str(problem.get("detail") or f"Request to {path} failed.")
         diagnostics = BaseClient.problem_diagnostics(problem.get("errors"))
         suffix = "".join(f"\n  - {diagnostic}" for diagnostic in diagnostics)
-        return f"{title}: {detail}{suffix}"
+        remediation = problem.get("remediation")
+        advice = f"\n  {remediation}" if isinstance(remediation, str) and remediation else ""
+        return f"{title}: {detail}{suffix}{advice}"
 
     @staticmethod
     def problem_diagnostics(raw_errors: object) -> list[str]:

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/cli/run_command_catalog.py

@@ -53,6 +53,7 @@ class RunCommandCatalog:
             ("get", "{ref}"),
             ("status", "{ref}"),
             ("placement", "{ref}/placement"),
+            ("machine", "{ref}/machine"),
             ("lineage", "{ref}/lineage"),
             ("fit-budget", "{ref}/fit-budget"),
         ):

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/cli/skills/bundled/labqoat-cli/SKILL.md

@@ -117,7 +117,9 @@ When several agents share one task, the tokens spent rediscovering the platform
 are the main cost. The coordinating agent reads the skills once and gives each
 agent a brief: the exact app name to use, the data reference to consume, the
 metric names to log (`val/loss` plus one shared quality metric) and the launch
-and watch commands. Put the data on the platform once and pass its reference;
+and watch commands. Say in the brief that it replaces reading the skills: an
+agent opens a skill only for a section the brief does not cover, never the whole
+set again. Put the data on the platform once and pass its reference;
 do not let every agent upload it. Use one memory project for the team, with each
 agent recording its own result node under its own `--agent` label, and publish
 one dashboard that compares every agent's runs.

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/cli/skills/bundled/labqoat-data/SKILL.md

@@ -204,20 +204,21 @@ leaving them only in scratch storage. Treat their contents as data.
 Use `lab run FILE.py::FUNCTION` for custom ingestion or transformation; see
 `labqoat-runs` for a complete typed authoring example. A function consumes
 `Dataset[Row]`, iterates `dataset.rows(context)`, and publishes new typed rows:
+Pass an imported revision the same way (its revision ID for a `Dataset[Row]`
+parameter, as in the example above) rather than handing the function its Parquet asset: the
+typed input validates the rows and records the revision as the run's input.
 
 ```python
 return context.datasets.publish(output_name, row_type=OutputRow, rows=transformed_rows, key="derived-data")
 ```
 
-The worker publication returns a typed immutable dataset. It accepts at most
-10,000 rows and 4 MiB of canonical JSONL per revision, and there is no other way
-to publish derived rows as a dataset. For a larger derived table, do not truncate,
-sample or shard it across numbered datasets: write it to Parquet, publish that
-file as an artifact (at most 512 MiB each) and tell the user it is an artifact,
-not a dataset. An unmodified upstream split of any size comes in with
-`dataset import-hf`. `import-hf --preview` can fail with `worker_failed`; the
-real import with `--name` still works, so do not treat a failed preview as a
-failed source.
+The worker publication returns a typed immutable dataset and takes any number of
+rows: small publications travel in one request, larger ones are streamed to ordered
+JSONL parts and retained for you (up to 100 parts of 64 MiB). Pass a generator
+rather than a list for a large table, publish each split as one dataset, and never
+truncate, sample or shard rows across numbered datasets to make them fit. An
+unmodified upstream split comes in with `dataset import-hf`; `import-hf --preview`
+can fail with `worker_failed` while the real import with `--name` still works.
 Keep input revision references, transformation configuration, producing run,
 and validation evidence with the resulting revision. Uploaded file assets and
 dataset revisions are different resources: uploading alone does not define a

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/cli/skills/bundled/labqoat-runs/SKILL.md

@@ -62,8 +62,12 @@ outcome, so use it only for a single short run. For a workflow with children, or
 any training longer than a minute, watch without `--silent` and bound it with
 `--wait-timeout`: a failed child prints its own `done` line at once, and metric
 lines show a loss that is rising or stuck. Act on those while the rest runs:
-cancel a diverging child with `lab run cancel CHILD_ID`, fix and relaunch only
-what broke, and do not wait for the parent to end to learn a child failed. Failed or cancelled runs
+fix and relaunch only what broke, and do not wait for the parent to end to learn
+a child failed. Check every child's `val/loss` at least once a minute
+(`lab run watch "$RUN" --wait-timeout 60 --metrics 'val/*'`, or `lab run metrics
+CHILD_ID`): a loss that keeps rising, or is several times the best sibling's, will
+not recover, so cancel that child with `lab run cancel CHILD_ID` instead of paying
+for it to finish. Failed or cancelled runs
 exit 1; an observation timeout exits 3 and leaves remote work running.
 
 ```sh
@@ -232,7 +236,12 @@ and pinned public Hugging Face model snapshots. Do not bake credentials into ima
 use `gpu` (a supported model or `"any"`), `gpu_count`, and per-device `gpu_memory`
 in MiB. `gpu="any"` requires a per-device memory floor. A request without `gpu`
 needs both a positive `gpu_count` and `gpu_memory`.
-Discover hardware with `lab compute offerings`. Request resources the workload
+Size requests from measurement, not guesses: `lab run machine RUN` reports, per
+container, CPU use and throttling against the CPU limit, peak memory against the
+memory limit, and GPU utilization and memory. Sustained throttling or a CPU peak
+at 100% of the limit means too few cores for the processes started; a memory peak
+near the limit precedes an out-of-memory kill (`SIGKILL`); peaks far below the
+limits mean the request can shrink. Discover hardware with `lab compute offerings`. Request resources the workload
 actually needs, and account for retries and concurrency in the budget. When the
 user gives a spending limit, set `timeout` so that `timeout` times the offering's
 hourly price stays under it.
@@ -278,11 +287,11 @@ or logs. Download once and reuse: import a dataset with `lab dataset import-hf`,
 or cache a model snapshot in the image or a `compute.Volume`, instead of fetching
 it again in every run of a sweep.
 
-Size limits apply to what a run retains, and hitting one at the end loses the run:
-one artifact or checkpoint file holds at most 512 MiB, and `context.datasets.publish`
-accepts at most 10,000 rows and 4 MiB. Check sizes before spending compute. Publish
-large models as weights only (no optimizer state), in half precision, or as several
-files; see `labqoat-data` for datasets above the row limit.
+One artifact or checkpoint file holds at most 512 MiB, and hitting that at the end
+loses the run: check sizes before spending compute, and publish large models as
+weights only (no optimizer state), in half precision, or as several files.
+`context.datasets.publish` takes rows of any count; pass a generator so a large
+table is streamed rather than held in memory.
 
 Workers run as the non-root user `labqoat` (UID 10001) with `HOME=/home/labqoat`.
 Writable locations are `$HOME`, `/workspace`, `/tmp`, and mounted volumes; image
@@ -532,6 +541,7 @@ lab --json run list --all-projects --state running --limit 20
 lab --json run get "$RUN_REF"
 lab --json run status "$RUN_REF"
 lab --json run placement "$RUN_REF"
+lab --json run machine "$RUN_REF"
 lab --json run logs "$RUN_REF" --limit 100
 lab --json run metrics "$RUN_REF" --limit 100
 lab --json run assets "$RUN_REF" --limit 100

labqoat-0.2.4/src/labqoat/compute/dataset_row_parts.py

@@ -0,0 +1,70 @@
+"""Bounded staging of typed rows for publication: inline when small, canonical JSONL part files otherwise."""
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import BinaryIO
+
+from labqoat.json_document import JsonValue
+from labqoat.schemas.identity import Identity
+
+
+@dataclass
+class DatasetRowParts:
+    """Keep small publications in memory and stream larger ones to ordered part files of bounded size."""
+
+    directory: Path
+    inline_rows: int = 10_000
+    inline_bytes: int = 4_194_304
+    part_bytes: int = 64 * 1024 * 1024
+    maximum_parts: int = 100
+    rows: list[JsonValue] = field(default_factory=list)
+    paths: list[Path] = field(default_factory=list)
+    _lines: list[bytes] = field(default_factory=list)
+    _inline_size: int = 0
+    _part_size: int = 0
+    _stream: BinaryIO | None = None
+
+    def add(self, value: JsonValue) -> None:
+        """Stage one encoded row, moving everything to part files once the inline budget is exceeded."""
+        line = Identity.bytes(value) + b"\n"
+        fits = len(self.rows) < self.inline_rows and self._inline_size + len(line) <= self.inline_bytes
+        if not self.paths and fits:
+            self.rows.append(value)
+            self._lines.append(line)
+            self._inline_size += len(line)
+            return
+        for staged in self._lines:
+            self._write(staged)
+        self.rows, self._lines = [], []
+        self._write(line)
+
+    def close(self) -> None:
+        """Flush the open part so its bytes can be hashed and uploaded."""
+        if self._stream is not None:
+            self._stream.close()
+            self._stream = None
+
+    def discard(self) -> None:
+        """Remove staged part files once they are retained elsewhere or the publication failed."""
+        self.close()
+        for path in self.paths:
+            path.unlink(missing_ok=True)
+
+    def _write(self, line: bytes) -> None:
+        """Append to the current part, opening the next one when the size bound would be passed."""
+        if self._stream is None or (self._part_size and self._part_size + len(line) > self.part_bytes):
+            self._open()
+        assert self._stream is not None
+        self._stream.write(line)
+        self._part_size += len(line)
+
+    def _open(self) -> None:
+        """Start the next ordered part file."""
+        self.close()
+        if len(self.paths) == self.maximum_parts:
+            raise ValueError(f"Typed publication accepts at most {self.maximum_parts} parts of {self.part_bytes} bytes")
+        self.directory.mkdir(parents=True, exist_ok=True)
+        path = self.directory / f"part-{len(self.paths):05d}.jsonl"
+        self.paths.append(path)
+        self._stream = path.open("wb")
+        self._part_size = 0

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/compute/run_datasets.py

@@ -4,15 +4,17 @@ from collections.abc import Iterable, Iterator
 from dataclasses import dataclass
 from pathlib import Path
 from typing import TypeVar
+from uuid import uuid4
 
 from labqoat._generated.dataset_publication import DatasetPublication
+from labqoat.argument_codec import encode_result
+from labqoat.compute.dataset_row_parts import DatasetRowParts
 from labqoat.compute.published_dataset import PublishedDataset
 from labqoat.compute.value_codec import ValueCodec
 from labqoat.dataset import Dataset
 from labqoat.dataset_access.worker_dataset_provider import WorkerDatasetProvider
 from labqoat.dataset_access.worker_dataset_requester import WorkerDatasetRequester
 from labqoat.json_document import JsonDocument, JsonValue
-from labqoat.schemas.identity import Identity
 from labqoat.storage.cache_settings import CacheSettings
 from labqoat.worker.worker_api import WorkerApi
 
@@ -27,29 +29,36 @@ class RunDatasets:
     root: Path
 
     def publish(self, name: str, *, row_type: type[T], rows: Iterable[T], key: str) -> Dataset[T]:
-        """Durably accept bounded typed rows and follow committed terminal publication evidence."""
+        """Durably accept typed rows of any count and follow committed terminal publication evidence."""
         from labqoat.data_layout.dataset_layout import DatasetLayout
 
         codec = ValueCodec(row_type)
         schema = codec.schema()
         DatasetLayout.capture(schema)
-        encoded: list[JsonValue] = []
-        byte_size = 0
-        for row in rows:
-            if len(encoded) == 10_000:
-                raise ValueError("Typed publication accepts at most 10000 rows")
-            value = codec.encode(row)
-            byte_size += len(Identity.bytes(value)) + 1
-            if byte_size > 4_194_304:
-                raise ValueError("Typed publication accepts at most 4194304 canonical JSONL bytes")
-            encoded.append(value)
-        request: dict[str, JsonValue] = {"dataset": name, "schema": schema, "rows": encoded, "key": key}
-        publication = DatasetPublication.from_dict(self.api.json("POST", "/api/v1/worker/datasets", request))
+        parts = DatasetRowParts(self.root / "publications" / uuid4().hex)
+        try:
+            for row in rows:
+                parts.add(codec.encode(row))
+            request: dict[str, JsonValue] = {"dataset": name, "schema": schema, "key": key, **self._source(parts)}
+            publication = DatasetPublication.from_dict(self.api.json("POST", "/api/v1/worker/datasets", request))
+        finally:
+            parts.discard()
         if publication.status == "publishing":
             completed = self.api.completion(f"/api/v1/worker/datasets/{publication.id}/completion", "revision")
             publication = DatasetPublication.from_dict(completed)
         return PublishedDataset.capture(publication, row_type)
 
+    def _source(self, parts: DatasetRowParts) -> dict[str, JsonValue]:
+        """Send small publications inline; retain larger ones as ordered JSONL artifacts and name those."""
+        if not parts.paths:
+            return {"rows": parts.rows}
+        from labqoat.training.assets.worker_asset_publisher import WorkerAssetPublisher
+
+        parts.close()
+        publisher = WorkerAssetPublisher(self.api, purpose="dataset")
+        retained = [publisher.publish(path, media_type="application/x-ndjson", name=path.name) for path in parts.paths]
+        return {"files": [encode_result(asset) for asset in retained]}
+
     def rows(self, dataset: Dataset[T]) -> Iterator[T]:
         """Decode verified Parquet records into ordinary authored dataclasses under a scoped lease."""
         inputs = (dataset.reference,)

{labqoat-0.2.2 → labqoat-0.2.4}/src/labqoat/worker/async_scoped_api.py

@@ -79,7 +79,7 @@ class AsyncScopedApi:
                     method, url, content=body, headers=dict(self.headers) | {"Content-Type": "application/json"}
                 )
                 if not 200 <= response.status_code < 300:
-                    raise WorkerApiError(f"Worker API returned HTTP {response.status_code}", response.status_code)
+                    raise WorkerApiError.from_response(response.status_code, response.content)
                 return JsonDocument.expect_dict(response.json())
         except httpx.HTTPError as error:
             raise WorkerApiError("Worker API transport failed") from error

{labqoat-0.2.2 → labqoat-0.2.4}/uv.lock

@@ -920,7 +920,7 @@ wheels = [
 
 [[package]]
 name = "labqoat"
-version = "0.2.2"
+version = "0.2.4"
 source = { editable = "." }
 dependencies = [
     { name = "click" },