letify 2.5.1__tar.gz → 2.5.2__tar.gz

{letify-2.5.1 → letify-2.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.5.1
+Version: 2.5.2
 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.5.1 → letify-2.5.2}/docs/SPEC.md

@@ -656,7 +656,15 @@ A **persistent channel** keeps one worker process alive behind a pipe pair. Mess
 
 A **one-shot channel** can only run a command and collect its output. Every call starts a fresh process, so nothing persists. It exists because some transports offer nothing more, and it refuses the operations that need persistence rather than pretending.
 
-The worker source cannot be sent on standard input as a script, because `python -` reads to end of file before compiling anything and the pipe has to stay open for requests. A small bootstrap stub passed with `-c` reads one line holding a decimal byte count from `sys.stdin.buffer`, reads that many bytes of UTF-8 worker source, executes them, and leaves standard input where it was. From then on both pipes carry frames only. The stub compares what it read against the count and raises `SystemExit` with `the letify worker source arrived short: <read> of <expected> bytes` rather than compiling a truncated program, because a program cut anywhere fails as a `SyntaxError` at whatever construct the cut landed inside, which names the symptom and hides the cause.
+The worker source cannot be sent on standard input as a script, because `python -` reads to end of file before compiling anything and the pipe has to stay open for requests. A small bootstrap stub passed with `-c` reads one line holding a decimal byte count from `sys.stdin.buffer`, reads that many bytes of UTF-8 worker source, executes them, and leaves standard input where it was. From then on both pipes carry frames only. The count line is `<byte count> <digest>`, where the digest is the first 16 bytes of the source's
+blake2b in hexadecimal, from `hashlib` so the stub needs nothing installed. The stub exits rather
+than compiling when either disagrees: `the letify worker source arrived short: <read> of <expected>
+bytes`, or `the letify worker source arrived corrupted: <read> bytes, digest <found>, expected
+<wanted>`. A program cut or shifted anywhere fails as a `SyntaxError` at whatever construct the
+damage landed inside, which names the symptom and hides the cause. The count alone is not enough,
+because a transport that loses one run of bytes and gains another of the same length keeps the count
+intact: a Kaggle session reported an unterminated triple-quoted string at a line that holds no quote
+in the source, which is what a shifted source looks like and what a digest catches.
 
 ### Frames <!-- id: frames -->
 

{letify-2.5.1 → letify-2.5.2}/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.5.1"
+__version__ = "2.5.2"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.5.1 → letify-2.5.2}/letify/protocol/worker.py

@@ -37,17 +37,35 @@ from . import wire as _wire
 #: enough to survive shell quoting reads a byte count line and that many bytes of source,
 #: execs them, and leaves standard input where it was.
 BOOTSTRAP = (
-    "import sys;"
+    "import sys,hashlib;"
     "b=sys.stdin.buffer;"
-    "n=int(b.readline());"
+    "h=b.readline().split();"
+    "n=int(h[0]);"
     "s=b.read(n);"
-    # Spec "Channels": a source cut anywhere compiles as whatever construct the cut landed
-    # inside, or runs and exits without serving, so the count is checked before it is run.
+    # Spec "Channels": a source cut or shifted anywhere compiles as whatever construct the
+    # damage landed inside, or runs and exits without serving. The count catches a cut and
+    # the digest catches a shift, which keeps the count intact.
     "len(s)==n or sys.exit("
     "'the letify worker source arrived short: %d of %d bytes'%(len(s),n));"
+    "d=hashlib.blake2b(s,digest_size=16).hexdigest();"
+    "d==h[1].decode() or sys.exit("
+    "'the letify worker source arrived corrupted: %d bytes, digest %s, expected %s'"
+    "%(len(s),d,h[1].decode()));"
     "exec(compile(s.decode(),'letify-worker','exec'))"
 )
 
+def count_line(body: bytes) -> bytes:
+    """The line the bootstrap stub reads before the source: its length and its digest.
+
+    Spec "Channels": the digest is the first 16 bytes of blake2b in hexadecimal, from
+    ``hashlib`` so the stub needs nothing installed.
+    """
+    import hashlib
+
+    digest = hashlib.blake2b(body, digest_size=16).hexdigest()
+    return b"%d %s\n" % (len(body), digest.encode("ascii"))
+
+
 _BODY = r'''
 import hashlib, io, queue, sys, tarfile, time, traceback
 

{letify-2.5.1 → letify-2.5.2}/letify/providers/kaggle_adapter.py

@@ -31,14 +31,20 @@ UNREACHABLE = 4
 #: The stub the shim starts the worker with, the one Channels describes: a byte count line,
 #: then that many bytes of source.
 STUB = (
-    "import sys;"
+    "import sys,hashlib;"
     "b=sys.stdin.buffer;"
-    "n=int(b.readline());"
+    "h=b.readline().split();"
+    "n=int(h[0]);"
     "s=b.read(n);"
-    # Spec "Channels": a source cut anywhere compiles as whatever construct the cut landed
-    # inside, or runs and exits without serving, so the count is checked before it is run.
+    # Spec "Channels": a source cut or shifted anywhere compiles as whatever construct the
+    # damage landed inside, or runs and exits without serving. The count catches a cut and
+    # the digest catches a shift, which keeps the count intact.
     "len(s)==n or sys.exit("
     "'the letify worker source arrived short: %d of %d bytes'%(len(s),n));"
+    "d=hashlib.blake2b(s,digest_size=16).hexdigest();"
+    "d==h[1].decode() or sys.exit("
+    "'the letify worker source arrived corrupted: %d bytes, digest %s, expected %s'"
+    "%(len(s),d,h[1].decode()));"
     "exec(compile(s.decode(),'letify-worker','exec'))"
 )
 

{letify-2.5.1 → letify-2.5.2}/letify/remoting/device/client.py

@@ -99,9 +99,21 @@ class Pending:
 
 
 #: Passed to ``python -c`` to start the worker: read a length-prefixed source, execute it.
+#: Spec "Channels": the count catches a cut and the digest catches a shift, which keeps the
+#: count intact, so neither failure reaches the compiler as a syntax error.
 BOOTSTRAP = (
-    "import sys;n=int(sys.stdin.buffer.readline());"
-    "exec(compile(sys.stdin.buffer.read(n),'letify-device','exec'))"
+    "import sys,hashlib;"
+    "b=sys.stdin.buffer;"
+    "h=b.readline().split();"
+    "n=int(h[0]);"
+    "s=b.read(n);"
+    "len(s)==n or sys.exit("
+    "'the letify device source arrived short: %d of %d bytes'%(len(s),n));"
+    "d=hashlib.blake2b(s,digest_size=16).hexdigest();"
+    "d==h[1].decode() or sys.exit("
+    "'the letify device source arrived corrupted: %d bytes, digest %s, expected %s'"
+    "%(len(s),d,h[1].decode()));"
+    "exec(compile(s,'letify-device','exec'))"
 )
 
 
@@ -1089,7 +1101,9 @@ def connect(
         target=client._drain_stderr, args=(process.stderr,), name=f"{name}-stderr", daemon=True
     ).start()
     try:
-        transport.raw(b"%d\n" % len(source) + source)
+        from ...protocol.worker import count_line
+
+        transport.raw(count_line(source) + source)
         client.start()
     except (TransportClosed, RuntimeLost) as exc:
         process.kill()

{letify-2.5.1 → letify-2.5.2}/letify/runtime/channel.py

@@ -654,14 +654,14 @@ class FramedChannel(Channel):
 
     def _send_worker(self) -> None:
         """Hand the worker source to the bootstrap stub: a byte count line, then the source."""
-        from ..protocol.worker import source
+        from ..protocol.worker import count_line, source
 
         connection = self._connection
         assert connection is not None
         data = source(text_frames=self.text_frames).encode("utf-8")
         connection.hello = None
         try:
-            connection.sender.raw(b"%d\n" % len(data) + data)
+            connection.sender.raw(count_line(data) + data)
         except OSError:
             # The worker is already gone. Waiting for its hello reports why.
             pass

{letify-2.5.1 → letify-2.5.2}/letify-core/Cargo.lock

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

{letify-2.5.1 → letify-2.5.2}/letify-core/Cargo.toml

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

{letify-2.5.1 → letify-2.5.2}/letify-ext/package-lock.json

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

{letify-2.5.1 → letify-2.5.2}/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.5.1",
+  "version": "2.5.2",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.5.1 → letify-2.5.2}/pyproject.toml

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

{letify-2.5.1 → letify-2.5.2}/tests/fake_kaggle_adapter.py

@@ -63,13 +63,9 @@ except (urllib.error.URLError, OSError) as exc:
 # The cell a real bridge executes carries a shim, because a kernel answers input() and not a
 # binary read. Here the same shape is a subprocess whose standard input and output are pipes:
 # the bridge copies lines in and out, exactly as it would copy them to input_request replies
-# and from stream messages.
-STUB = (
-    "import sys;"
-    "b=sys.stdin.buffer;"
-    "n=int(b.readline());"
-    "exec(compile(b.read(n).decode(),'letify-worker','exec'))"
-)
+# and from stream messages. The stub is the real one rather than a copy: a copy of it drifted
+# from the real stub when the count line gained a digest, and the drift read as a dead worker.
+from letify.providers.kaggle_adapter import STUB  # noqa: E402
 
 worker = subprocess.Popen(
     [sys.executable, "-u", "-c", STUB],

{letify-2.5.1 → letify-2.5.2}/tests/test_kaggle.py

@@ -1660,13 +1660,13 @@ def test_the_stub_refuses_a_worker_source_that_arrived_short() -> None:
     """
     import subprocess
 
-    from letify.protocol.worker import BOOTSTRAP, source
+    from letify.protocol.worker import BOOTSTRAP, count_line, source
 
     body = source().encode("utf-8")
     # The count says the whole source; the pipe carries all but the last 284 bytes.
     done = subprocess.run(
         [sys.executable, "-u", "-c", BOOTSTRAP],
-        input=b"%d\n" % len(body) + body[:-284],
+        input=count_line(body) + body[:-284],
         capture_output=True,
         timeout=120,
     )
@@ -1716,3 +1716,46 @@ def test_a_kernel_line_stays_inside_the_limit_a_kernel_carries() -> None:
     assert len(source().encode("utf-8")) > KaggleChannel.WRITE_LIMIT, (
         "the source must cross as several lines, or this pins nothing"
     )
+
+
+def test_the_stub_refuses_a_worker_source_whose_bytes_were_shifted() -> None:
+    """Spec "Channels": the count alone misses a loss and a gain of the same length.
+
+    KICT's Kaggle session reported an unterminated triple-quoted string at generated line
+    3077, which holds `job = _JOBS.get()` in that build and no quote at all, so the source
+    was shifted rather than cut. A shift keeps the byte count intact.
+    """
+    import subprocess
+
+    from letify.protocol.worker import BOOTSTRAP, count_line, source
+
+    body = source().encode("utf-8")
+    # Four bytes lost from the middle and four gained at the end: the same length.
+    shifted = body[:50_000] + body[50_004:] + b"\n" * 4
+    assert len(shifted) == len(body)
+    done = subprocess.run(
+        [sys.executable, "-u", "-c", BOOTSTRAP],
+        input=count_line(body) + shifted,
+        capture_output=True,
+        timeout=120,
+    )
+    assert b"arrived corrupted" in done.stderr, done.stderr[-2000:]
+    assert b"SyntaxError" not in done.stderr
+
+
+def test_a_worker_source_that_arrives_whole_still_runs() -> None:
+    """Spec "Channels": the check costs the good case nothing, so the worker still starts."""
+    import subprocess
+
+    from letify.protocol.worker import BOOTSTRAP, count_line, source
+
+    body = source().encode("utf-8")
+    done = subprocess.run(
+        [sys.executable, "-u", "-c", BOOTSTRAP],
+        input=count_line(body) + body,
+        capture_output=True,
+        timeout=120,
+    )
+    # The worker announces itself and then reads, so closing its input ends it cleanly.
+    assert b"arrived" not in done.stderr, done.stderr[-2000:]
+    assert done.stdout, "the worker said nothing, so it never started"

{letify-2.5.1 → letify-2.5.2}/tests/test_protocol.py

@@ -187,10 +187,10 @@ def test_a_worker_call_whose_body_imports_letify_while_running_names_the_reason(
 
         return inside.session_cache("value", lambda: 1)
 
-    from letify.protocol.worker import SOURCE
+    from letify.protocol.worker import SOURCE, count_line
 
     source = SOURCE.encode()
-    stdin = bytearray(b"%d\n" % len(source) + source)
+    stdin = bytearray(count_line(source) + source)
     sender = wire.Sender(lambda view: stdin.extend(view) or view.nbytes)
     head, buffers = codec.dumps_call_parts(work, (), {})
     sender.message(wire.REQUEST, 1, {"op": "call", "payload": head, "buffers": buffers})

{letify-2.5.1 → letify-2.5.2}/tests/test_providers.py

@@ -1457,7 +1457,7 @@ def test_a_sandbox_channel_sends_the_worker_once_and_then_framed_requests(
 ) -> None:
     import base64
 
-    from letify.protocol.worker import SOURCE
+    from letify.protocol.worker import SOURCE, count_line
     from letify.protocol.worker import source as worker_source
 
     provider = provider_of(Modal, "m")
@@ -1471,7 +1471,7 @@ def test_a_sandbox_channel_sends_the_worker_once_and_then_framed_requests(
         written = b"".join(base64.b64decode(r["data"]) for r in fake_modal.requests("write"))
         # The worker source went out exactly once, behind its byte count line, with the flag
         # that makes the sandbox write its frames as base64 lines.
-        assert written.count(b"%d\n" % len(source) + source) == 1
+        assert written.count(count_line(source) + source) == 1
         assert SOURCE.encode() not in written
     finally:
         provider.stop(runtime)