letify 2.6.5__tar.gz → 2.6.6__tar.gz

{letify-2.6.5 → letify-2.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.6.5
+Version: 2.6.6
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs

{letify-2.6.5 → letify-2.6.6}/docs/SPEC.md

@@ -1365,6 +1365,14 @@ A call that detected data prints one line on standard error:
 
 The line is printed when the call has at least one input file, after the call's outcome is known, because what was sent during the call is not known before then. Sizes are in MiB with one decimal. `<the bucket>` is named when the bytes come from the bucket. `before the call` counts the first wave of The send order and the first wave, `during it` counts what the background sender delivered while the call ran, and the rate covers both. `first access waited` is the wall clock time in which at least one reader was blocked on a blob that had not arrived, and it is `0.0` when the send order was right.
 
+The bytes of a blob still on the way are reported too, because the rate counts only blobs that
+completed and a single large blob in flight therefore reads as `0.0 MiB/s` however fast it is moving.
+A line whose dropped clause names files ends with how far they got,
+`, 3 files 14985.8 MiB dropped when the call ended, 4512.0 MiB of them had arrived`, and the
+background sender draws the same `uploading` progress line the first wave draws, which it did not
+before: a blob sent beside the call reported nothing at all, so a transfer in progress and a transfer
+that had never started looked the same. Both cost a reader an afternoon.
+
 `already on` counts the blobs the runtime answered `data_have` with, not what is left after subtracting what was sent. The two differ whenever a blob was neither already there nor fully sent, and subtracting reports such a blob as having been there all along, which is the opposite of what happened. A blob the background sender was still carrying when the call returned is one of those, so the line ends with `, <files> files <size> dropped when the call ended` whenever there is one, and omits that clause when there is none. A dropped blob is not a failure: the call is over and its bytes are no longer needed, which is why the sender is cancelled. It is reported because a line that accounts for every detected file except the dropped ones cannot be read.
 
 Cancelling the sender removes the partial file of a blob it was writing, in the runtime's blob cache as well as a parallel put's staged ranges. A full sized partial left behind counts against the cache budget and is never completed, because the digest it would be sealed under is only written when every range has arrived.

{letify-2.6.5 → letify-2.6.6}/letify/__init__.py

@@ -66,7 +66,7 @@ distributed: Final = Host.distributed
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "2.6.5"
+__version__ = "2.6.6"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.6.5 → letify-2.6.6}/letify/store/pathdata.py

@@ -485,6 +485,32 @@ def _mib(size: int) -> str:
     return f"{size / (1 << 20):.1f} MiB"
 
 
+class _Carried:
+    """One blob's progress, recorded on the stream and forwarded to the real meter.
+
+    Spec "Data log line": the bytes of a blob still on the way are reported, and only the
+    blob's own sender knows how far it got.
+    """
+
+    def __init__(self, stream: Any, digest: str, meter: Any) -> None:
+        self._stream = stream
+        self._digest = digest
+        self._meter = meter
+
+    def update(self, done: int) -> None:
+        self._stream.carried[self._digest] = done
+        if self._meter is not None:
+            self._meter.update(done)
+
+    def advance(self, size: int) -> None:
+        if self._meter is not None:
+            self._meter.advance(size)
+
+    def finish(self) -> None:
+        if self._meter is not None:
+            self._meter.finish()
+
+
 class _Uploaded:
     """Bytes sent so far, drawn as a progress line when the upload is large.
 
@@ -626,6 +652,10 @@ class Stream:
         #: Digests whose send finished. ``_sent`` holds the ones it began, so a blob the
         #: sender was carrying when the call ended is in one and not the other.
         self.done: set[str] = set()
+        #: Bytes of each blob handed to the runtime, including one still on the way.
+        self.carried: dict[str, int] = {}
+        #: The meter for blobs sent beside the call, spec "Data log line".
+        self._meter: _Uploaded | None = None
         self.before_files = self.before_bytes = 0
         self.during_files = self.during_bytes = 0
         self.before_seconds = self.during_seconds = 0.0
@@ -750,9 +780,22 @@ class Stream:
         digest = self._take()
         if digest is None:
             return False
-        self._send(digest, None)
+        self._send(digest, self._beside())
         return True
 
+    def _beside(self) -> _Uploaded:
+        """The meter for blobs sent beside the call, made at the first one.
+
+        Spec "Data log line": without one, a blob sent beside the call reported nothing,
+        so a transfer in progress and one that never started looked the same.
+        """
+        with self._lock:
+            if self._meter is None:
+                left = [d for d in self.plan.missing if d not in self.done]
+                total = sum(self.plan.weight(digest)[1] for digest in left)
+                self._meter = _Uploaded(len(left), total)
+            return self._meter
+
     def _take(self) -> str | None:
         with self._lock:
             while self._queue:
@@ -916,6 +959,7 @@ class Stream:
         size = self.plan.sizes.get(digest, 0)
         local = self.plan.files[digest]
         bucket = self.plan.bucket
+        meter = _Carried(self, digest, meter)
         uploaded = True
         if bucket is None:
             # The cost of opening the connections is weighed only while the pool is cold:
@@ -1014,9 +1058,13 @@ class Stream:
         missing_weight = [plan.weight(digest) for digest in plan.missing]
         already_files = plan.detected_files - sum(files for files, _b in missing_weight)
         already_bytes = plan.detected_bytes - sum(total for _f, total in missing_weight)
-        dropped_weight = [plan.weight(digest) for digest in self.dropped]
+        dropped = self.dropped
+        dropped_weight = [plan.weight(digest) for digest in dropped]
         dropped_files = sum(files for files, _b in dropped_weight)
         dropped_bytes = sum(total for _f, total in dropped_weight)
+        # Spec "Data log line": the rate counts only blobs that completed, so a large one
+        # in flight reads as 0.0 MiB/s however fast it is moving.
+        arrived = sum(self.carried.get(digest, 0) for digest in dropped)
         line = (
             f"data {plan.detected_files} files {_mib(plan.detected_bytes)} detected, "
             f"{already_files} files {_mib(already_bytes)} already on {plan.where}, "
@@ -1029,6 +1077,8 @@ class Stream:
             line += (
                 f", {dropped_files} files {_mib(dropped_bytes)} dropped when the call ended"
             )
+            if arrived:
+                line += f", {_mib(arrived)} of them had arrived"
         install.log(line)
         if stats.get("files"):
             install.log(

{letify-2.6.5 → letify-2.6.6}/letify-core/Cargo.lock

@@ -138,7 +138,7 @@ dependencies = [
 
 [[package]]
 name = "letify-agent"
-version = "2.6.5"
+version = "2.6.6"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -146,7 +146,7 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "2.6.5"
+version = "2.6.6"
 dependencies = [
  "letify-wire",
 ]
@@ -164,7 +164,7 @@ dependencies = [
 
 [[package]]
 name = "letify-wire"
-version = "2.6.5"
+version = "2.6.6"
 
 [[package]]
 name = "libc"

{letify-2.6.5 → letify-2.6.6}/letify-core/Cargo.toml

@@ -8,7 +8,7 @@ resolver = "3"
 members = ["letify-wire", "letify-driver", "letify-agent", "letify-quic"]
 
 [workspace.package]
-version = "2.6.5"
+version = "2.6.6"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

{letify-2.6.5 → letify-2.6.6}/letify-ext/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "letify-status",
-  "version": "2.6.5",
+  "version": "2.6.6",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "letify-status",
-      "version": "2.6.5",
+      "version": "2.6.6",
       "license": "SEE LICENSE IN LICENSE",
       "devDependencies": {
         "@types/node": "^18.19.0",

{letify-2.6.5 → letify-2.6.6}/letify-ext/package.json

@@ -2,7 +2,7 @@
   "name": "letify-status",
   "displayName": "letify Status",
   "description": "letify quota and GPU activity in the status bar, read from the letify CLI.",
-  "version": "2.6.5",
+  "version": "2.6.6",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.6.5 → letify-2.6.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "letify"
-version = "2.6.5"
+version = "2.6.6"
 description = "Declarations that become infrastructure."
 readme = "README.md"
 requires-python = ">=3.11"

{letify-2.6.5 → letify-2.6.6}/tests/test_data_streaming.py

@@ -1757,3 +1757,66 @@ def test_a_blob_that_never_starts_still_times_out_and_says_how_far_it_got(
     message = str(failure.value)
     assert "did not arrive" in message, message
     assert "arrived" in message, message
+
+
+def test_a_blob_sent_beside_the_call_reports_its_bytes(
+    let, cpu, project, capsys, monkeypatch
+) -> None:
+    """Spec "Data log line": a transfer in progress read the same as one never started.
+
+    KICT's 11.3 GB table was moving the whole time and the line said 0.0 MiB/s, because
+    the rate counts only blobs that completed and the background sender was given no
+    meter at all.
+    """
+    from letify.store import pathdata
+
+    big = project / "beside.bin"
+    big.write_bytes(b"q" * (3 << 20))
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_MIB", 0.0)
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_FILES", 0)
+    monkeypatch.setattr(pathdata, "WAIT_TIMEOUT_S", 4.0)
+    def stalled(runtime, pipeline, blobs, digest, local, size, meter):
+        # A third of the blob is reported as handed over and then the send stops, which
+        # is the shape of a blob the sender was carrying when the call ended.
+        meter.update(1 << 20)
+        raise RuntimeFailure("the transfer stream failed")
+
+    monkeypatch.setattr(pathdata, "_put", stalled)
+
+    @let.function(device=cpu, host=letify.remote, retries=0)
+    def peek(path) -> int:
+        return len(path.read_bytes())
+
+    with pytest.raises(RuntimeFailure):
+        peek(path=big)
+    lines = [
+        text
+        for text in capsys.readouterr().err.splitlines()
+        if text.startswith("letify: data ") and "detected," in text
+    ]
+    assert lines
+    assert "dropped when the call ended" in lines[0], lines[0]
+    assert "had arrived" in lines[0], lines[0]
+
+
+def test_a_large_blob_beside_the_call_draws_the_progress_line(
+    let, cpu, project, capsys, monkeypatch
+) -> None:
+    """Spec "Data log line": the background sender draws the same line the wave draws.
+
+    KICT reported no 'uploading' line at all while 11.3 GB moved beside a call, because
+    the background sender was given no meter.
+    """
+    from letify.store import pathdata
+
+    big = project / "wide.bin"
+    big.write_bytes(b"w" * (70 << 20))
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_MIB", 0.0)
+    monkeypatch.setattr(pathdata, "FIRST_WAVE_FILES", 0)
+
+    @let.function(device=cpu, host=letify.remote)
+    def read_it(path) -> int:
+        return len(path.read_bytes())
+
+    assert read_it(path=big) == 70 << 20
+    assert "uploading" in capsys.readouterr().err