letify 2.8.2__tar.gz → 2.8.4__tar.gz

{letify-2.8.2 → letify-2.8.4}/PKG-INFO

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

@@ -924,6 +924,8 @@ A top-level argument whose serialized size is 64 KiB or more is replaced by a `B
 
 A `bytes` argument is hashed as it is. Any other argument is pickled with protocol 5 and a `buffer_callback` through `codec.pickle_value_parts`, cloudpickle underneath rather than the standard library's `pickle.Pickler`, and the digest is taken over the pickle and then each out-of-band buffer in order, with no joined copy. The digest is blake3 with 16 byte output, or blake2b from the standard library where blake3 is missing.
 
+A digest names its own algorithm. A blake3 digest is the 32 hexadecimal characters of the 16 byte output, unchanged, so every digest already stored in a cache, a volume or Drive stays valid. A digest computed with blake2b because blake3 is missing is `b2-` followed by the 32 hexadecimal characters of the 16 byte blake2b output. Whoever checks a digest picks the algorithm from the digest, through `codec.hasher_for`, so a worker without blake3 and a client with it agree on every blob, archive, write-back file and handoff, and no handshake is needed. A side that cannot compute the algorithm of a digest it was given, a worker without blake3 handed a blake3 digest, does not check it and trusts the sender, and a name it computes itself uses its own algorithm. A placed file is compared by the algorithm of its recorded digest, so a worker without blake3 does not report an unchanged file as an output.
+
 cloudpickle rather than plain `pickle` because a `pickle.Pickler` writes a class or function defined in the caller's own run script as a name reference, `__main__.<name>`, and the worker's own `__main__` is not that script, so unpickling such a blob fails with `AttributeError: Can't get attribute '<name>' on <module '__main__' ...>`. cloudpickle ships such an object by value instead, the same as it already does for the call itself in `codec.dumps_call_parts`, so an argument too large to inline behaves the same as one that is not. The cost of cloudpickle's extra dispatch over plain `pickle` is in the noise: it only intercepts function, class and module objects, not the bulk of a large value, so a 256 MiB buffer or a multi-megabyte list of plain values serializes within a few percent of the same time either way, measured on this machine. There is accordingly no branch between the two picklers.
 
 The digest of an immutable argument is cached on the `Runtime` for the life of the session, so a repeated argument is not hashed again. Immutable means a `bytes` object, or an object that supports weak references and exposes a read-only buffer, such as a NumPy array with `writeable` set to `False`. A `bytes` entry holds a reference to its object so its id cannot be reused, and at most 16 such entries are kept, least recently used first out. Any other argument is pickled and hashed on every call, because it may have changed.
@@ -1088,7 +1090,7 @@ neither side holds it whole:
   returns `{"digest", "size", "dir"}`. The client receives the file with the stream a write-back
   uses, checks the digest as the pieces arrive into a scratch file beside the store, and renames it
   into the store with `Store.adopt_file`. The staging directory is removed afterwards. The digest
-  is the store's content digest (blake3 truncated to 16 bytes, blake2b without blake3).
+  is the store's content digest (blake3 truncated to 16 bytes, or `b2-` and blake2b where the worker has no blake3), and the client checks it with the algorithm the digest names.
 - Restore: a blob of more than one piece (8 MiB) that the store holds as a file is sent with
   `data_put` pieces into a staging directory beside the destination, then moved into place and
   unpacked by the worker op `place_blob`. Smaller blobs, and any blob from a store that does not
@@ -1114,6 +1116,8 @@ the kind this rule exists to catch, and the session that syncs instead both reco
 decides afresh whether the archive is worth keeping. The cost of that is one sync; the cost of
 trusting it is the transfer this rule was measured to avoid.
 
+A failure to cache the environment through the client's own store at boot, the pack, the stream back or the store write, never fails the session: it says `letify: <runtime>: not caching the environment (<reason>)` and the session goes on, the same as a failed pack on the workspace root.
+
 Packing is said, because it is a step that can take minutes and had nothing reporting it:
 `letify: <runtime>: caching the environment, 2.1 GB`. Skipping it is said too, because it is a
 decision letify made rather than a thing that did not
@@ -1162,7 +1166,7 @@ The archive is `<workspace root>/env-archives/<env key>-<platform>.tar`, uncompr
 
 The client's inbound link is the weak one, so the store path is slower than the build in both directions. Compression costs more than it saves on the volume, so the archive is not compressed.
 
-After a successful sync and interpreter check, the runtime says `caching the environment on the workspace root, <size>`, runs tar from the project directory's parent into a temporary name beside the destination, and renames it into place, so a concurrent session never reads a half written archive. Nothing is sent to the client, and no measured rate gates the pack, because the transfer stays inside the provider.
+After a successful sync and interpreter check, the runtime says `caching the environment on the workspace root, <size>`, runs tar from the project directory's parent into a temporary name beside the destination, and renames it into place, so a concurrent session never reads a half written archive. The temporary name carries 16 random hex digits, `<archive>.<hex>.partial`, not the process id, because every Modal sandbox runs its worker under the same small pid, so two sessions packing the same environment at once wrote one file and one of them failed with tar exit status 2. A pack that fails for any reason removes its temporary file, says `letify: <runtime>: not caching the environment on the workspace root (<reason>)`, and the session goes on: the environment is already built and checked, so a failed cache never fails the session or its call. Nothing is sent to the client, and no measured rate gates the pack, because the transfer stays inside the provider.
 
 At the start of `install_env`, when that archive exists on the runtime, the runtime says `restoring the environment from the workspace root`, extracts it into the project directory's parent, and validates the interpreter with the same check an archive restore uses. The restore refuses a member whose path escapes the destination and allows the absolute symlinks a `.venv` needs. A directory an earlier session left under the same name is removed first. When validation fails, the runtime removes the extracted tree, syncs, and replaces the archive. `Runtime.env_source` is `"workspace"` after this restore. This path is taken before and instead of the store path, and such a provider never uses the client store or the bucket store for its environment.
 
@@ -1931,7 +1935,7 @@ A jump host that letify cannot log in to, or whose `authorized_keys` it cannot e
 
 > Colab is a `Shell` whose rendezvous is `colab exec`. It has no forward SSH, and its fallback is `colab exec` with the Colab file API.
 
-The Colab CLI runs as `uv tool run --from google-colab-cli colab`, with `jupyter-kernel-client<1` pinned, because release 0.6.0 of the CLI calls an API that jupyter-kernel-client 1.0 removed. `colab new` and `colab stop` manage the session. `Colab.sessions()` reads `colab sessions` and returns the first word of each listing line. The CLI prints a session as `[<name>] <id> | Hardware: <hardware> | Variant: <variant>`, so a first word in square brackets gives the name inside them. A line starting with `[colab]` is a message from the CLI, such as `[colab] No active sessions found on server.`, and names no session, so an account with no session returns an empty list.
+The Colab CLI runs as `uv tool run --from google-colab-cli colab`, with `jupyter-kernel-client<1` pinned, because release 0.6.0 of the CLI calls an API that jupyter-kernel-client 1.0 removed. `colab new` and `colab stop` manage the session. `Colab.sessions()` reads `colab sessions` and returns the first word of each listing line. The CLI prints a session as `[<name>] <id> | Hardware: <hardware> | Variant: <variant>`, so a first word in square brackets gives the name inside them. A line starting with `[colab]` is a message from the CLI, such as `[colab] No active sessions found on server.`, and names no session, so an account with no session returns an empty list. `colab new` runs through the CLI's own Python with a request timeout of 600 s instead of google-auth's 120 s. google-auth binds `google.auth.transport.requests._DEFAULT_TIMEOUT` into `AuthorizedSession.request`'s signature when the module loads, so setting the module value alone changes nothing: the script sets it to 600 and wraps `AuthorizedSession.request` to default `timeout` to it, then calls the CLI's entry point `colab_cli.cli:main`. That is needed because the assignment request for an A100 can take longer than 120 s to answer and the CLI then fails with `ReadTimeout` while the server goes on assigning the machine. letify's own limit on `colab new` stays 900 s.
 
 **An assignment with no session.** `colab new` can fail after Colab has already assigned a machine, for example with `ReadTimeout` after 120 s, and the machine then bills (14.2 compute units per hour for an A100) with no local session state. `colab sessions` lists it as `[?] <endpoint> | ...`, and `colab stop -s <name>` cannot reach it. `Colab.create_session` therefore lists the account's assignments before `colab new`. When `colab new` raises, for any reason, it lists them again, releases every `?` assignment whose endpoint was not in the first list, and re-raises the original error. An assignment that existed before the attempt is never released. Each release prints one line on standard error naming the endpoint. When the first or the second listing fails, one line on standard error names the endpoint check and the error, and the original error is still the one raised. An assignment is released by endpoint with `Client.unassign` of the Colab CLI, run as `uv tool run --from google-colab-cli python -c <script> <endpoint>` with the account's environment, because the CLI has no command for it. `Colab.orphans()` returns the endpoints of the `?` rows of `colab sessions` and `Colab.stop_orphan(endpoint)` releases one, so `letify stop --orphans` covers Colab as it covers Kaggle.
 
@@ -1949,7 +1953,7 @@ Colab limits outbound UDP to roughly 200 packets per second, so rank 3 is expect
 
 Kaggle reports 2.0 MiB/s, measured on a live account sending 64 MiB over the kernel bridge, and an account overrides it with `fallback_mib_per_s`. Without this a live session refused a punched link at down 8.1 MiB/s for being under the 10 MiB/s floor and then carried 26 GB over the 2 MiB/s bridge instead, which is the opposite of what the floor is for. Taking the fallback is also never silent: the reason is printed, because a session that quietly changed channel is one nobody can account for.
 
-A `channel = "exec"` entry skips the pipeline and uses the fallback directly. A Colab VM has no SSH server on the port letify splices to, so the rendezvous request asks the remote half to start one first. The remote half connects to `127.0.0.1:<ssh_port>`, and when no line starting with `SSH-` arrives within 3 s it installs `openssh-server` if `/usr/sbin/sshd` is missing, creates `/run/sshd`, runs `ssh-keygen -A` so the server has host keys, and starts `/usr/sbin/sshd -p <ssh_port> -o ListenAddress=127.0.0.1`. `ssh-keygen -A` creates only the keys that are missing, and it is needed because a Kaggle image ships `sshd` with no host key at all: the install step above is skipped since the package is already there, and a server with no host key accepts the connection and closes it before the banner, which the client reports as `Connection closed by 127.0.0.1 port <port>` with no reason. The port is explicit because a Colab image ships `sshd` configured for `127.0.0.1:2222`, so starting it with its own configuration leaves port 22 closed. An SSH server that already answers on the port is used as it is. The request carries the account's public key, `key` with `.pub` appended, which the remote side adds to `authorized_keys`. An account with no `key`, or whose `.pub` file is missing, has nothing the VM could authorize, so its Colab rendezvous is unavailable with the reason `no key`: `tcp_punch` and `tailcat` are skipped with that reason and the fallback carries the session. SSH over a punched or Tailcat link logs in as `root` unless `user` says otherwise.
+A `channel = "exec"` entry skips the pipeline and uses the fallback directly. A Colab VM has no SSH server on the port letify splices to, so the rendezvous request asks the remote half to start one first. The remote half connects to `127.0.0.1:<ssh_port>`, and when no line starting with `SSH-` arrives within 3 s it installs `openssh-server` if `/usr/sbin/sshd` is missing, creates `/run/sshd`, runs `ssh-keygen -A` so the server has host keys, and starts `/usr/sbin/sshd -f /etc/ssh/sshd_config.letify -p <ssh_port> -o ListenAddress=127.0.0.1`. That file is the image's `/etc/ssh/sshd_config` with every `MaxStartups` line removed and `MaxStartups 64:30:128` as its first line, or that line alone when the image has no file. A Colab image's file sets `MaxStartups 1`, so the server dropped every connection that arrived while another was still authenticating, and a command-line `-o MaxStartups` does not override the file. Over `reverse_ssh` the transfer streams of a session arrive at once, so every one after the first ended with `Connection closed by 127.0.0.1 port <port>` and the call failed with `the worker exited before it was ready`. With the file, one 190.7 MiB blob crossed a reverse SSH link from a Colab CPU runtime in 5.4 s, 35.5 MiB/s. `ssh-keygen -A` creates only the keys that are missing, and it is needed because a Kaggle image ships `sshd` with no host key at all: the install step above is skipped since the package is already there, and a server with no host key accepts the connection and closes it before the banner, which the client reports as `Connection closed by 127.0.0.1 port <port>` with no reason. The port is explicit because a Colab image ships `sshd` configured for `127.0.0.1:2222`, so starting it with its own configuration leaves port 22 closed. An SSH server that already answers on the port is used as it is. The request carries the account's public key, `key` with `.pub` appended, which the remote side adds to `authorized_keys`. An account with no `key`, or whose `.pub` file is missing, has nothing the VM could authorize, so its Colab rendezvous is unavailable with the reason `no key`: `tcp_punch` and `tailcat` are skipped with that reason and the fallback carries the session. SSH over a punched or Tailcat link logs in as `root` unless `user` says otherwise.
 
 A Colab VM keeps its GPU driver libraries in `/usr/lib64-nvidia`, and only the notebook kernel's own environment names that directory in `LD_LIBRARY_PATH`. A login shell does not, so a worker started over SSH finds no `libnvidia-ml.so` and no `libcuda.so`: `nvidia-smi` fails and `torch.cuda.is_available()` is false on a session that holds a GPU. Every command letify runs over a Colab link, the worker and the `check` command included, is therefore prefixed with `LD_LIBRARY_PATH=/usr/lib64-nvidia${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}`, which keeps a path the machine already set. The `colab exec` fallback needs no prefix, because it runs inside the kernel.
 

{letify-2.8.2 → letify-2.8.4}/letify/__init__.py

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

{letify-2.8.2 → letify-2.8.4}/letify/protocol/codec.py

@@ -130,6 +130,10 @@ class _CallPickler(cloudpickle.Pickler):
         return super().reducer_override(obj)
 
 
+#: Prefix of a digest computed with blake2b because blake3 was missing. A blake3 digest has none.
+BLAKE2B_PREFIX = "b2-"
+
+
 def _hasher() -> Any:
     """A fresh incremental hasher: blake3 on every core, or blake2b where blake3 is missing."""
     try:
@@ -146,10 +150,28 @@ def new_hasher() -> Any:
     return _hasher()
 
 
+def hasher_for(digest: str) -> Any | None:
+    """A fresh hasher of the algorithm ``digest`` names, or None where it cannot be computed.
+
+    Spec "Argument addressing": a digest names its own algorithm, so a side checking one
+    follows the side that computed it. None means blake3 is missing here and the digest is
+    blake3, so the check cannot be made.
+    """
+    if digest.startswith(BLAKE2B_PREFIX):
+        import hashlib
+
+        return hashlib.blake2b(digest_size=16)
+    try:
+        import blake3
+    except ImportError:
+        return None
+    return blake3.blake3(max_threads=blake3.blake3.AUTO)
+
+
 def finish_digest(hasher: Any) -> str:
-    """The content address a hasher from ``new_hasher`` has accumulated."""
+    """The content address a hasher from ``new_hasher`` or ``hasher_for`` has accumulated."""
     if hasher.name == "blake2b":
-        return str(hasher.hexdigest())
+        return BLAKE2B_PREFIX + str(hasher.hexdigest())
     return str(hasher.hexdigest(length=16))
 
 
@@ -158,14 +180,13 @@ def digest_parts(parts: Iterable[Any]) -> str:
 
     blake3 is preferred because it hashes at several gigabytes per second, which
     keeps hashing orders of magnitude away from being the bottleneck on any real
-    network link. blake2b from the standard library is the fallback.
+    network link. blake2b from the standard library is the fallback, and its digests
+    carry ``BLAKE2B_PREFIX``.
     """
     hasher = _hasher()
     for part in parts:
         hasher.update(part)
-    if hasher.name == "blake2b":
-        return hasher.hexdigest()
-    return hasher.hexdigest(length=16)
+    return finish_digest(hasher)
 
 
 def digest_of(payload: bytes) -> str:
@@ -297,6 +318,7 @@ __all__ = [
     "dumps_call",
     "dumps_call_parts",
     "finish_digest",
+    "hasher_for",
     "new_hasher",
     "parse",
     "split_output",

{letify-2.8.2 → letify-2.8.4}/letify/protocol/worker.py

@@ -247,11 +247,9 @@ def _release_output():
 
 
 def _digest(payload):
-    try:
-        import blake3
-        return blake3.blake3(payload).hexdigest(length=16)
-    except ImportError:
-        return hashlib.blake2b(payload, digest_size=16).hexdigest()
+    hasher = _data_new_hasher()
+    hasher.update(payload)
+    return _data_finish(hasher)
 
 
 def _resolve(value):
@@ -394,20 +392,22 @@ def _letify_replica(replica):
     _replicas._WHO.rate_bps = replica.get("rate_bps")
 
 
-def _data_hash_file(path):
-    """The file digest of a file on the runtime: blake3 when present, else blake2b."""
-    hasher = _data_hasher()
+def _data_hash_file(path, like=None):
+    """The file digest of a file on the runtime: blake3 when present, else blake2b.
+
+    With ``like``, a digest the file may already be named by, the algorithm that digest
+    names is used when it can be, so the result is comparable with it.
+    """
+    hasher = _data_hasher(like) if like is not None else None
     if hasher is None:
-        hasher = hashlib.blake2b(digest_size=16)
+        hasher = _data_new_hasher()
     with open(path, "rb") as handle:
         while True:
             piece = handle.read(1 << 22)
             if not piece:
                 break
             hasher.update(piece)
-    if hasher.name == "blake2b":
-        return hasher.hexdigest()
-    return hasher.hexdigest(length=16)
+    return _data_finish(hasher)
 
 
 def _data_same_bytes(path, digest):
@@ -418,7 +418,7 @@ def _data_same_bytes(path, digest):
     Never raises; a file that cannot be read is not the file the digest promised.
     """
     try:
-        return _data_hash_file(path) == digest
+        return _data_hash_file(path, digest) == digest
     except OSError:
         return False
 
@@ -453,7 +453,7 @@ def _data_collect(data, placed):
             # The placed record ends with the cache stamp, which is not part of the comparison.
             if known is not None and known[1:4] == (info.st_ino, info.st_size, info.st_mtime_ns):
                 continue
-            digest = _data_hash_file(full)
+            digest = _data_hash_file(full, known[0] if known is not None else None)
             if known is not None and known[0] == digest:
                 continue
             final = _data_file(data["blobs"], digest)
@@ -667,7 +667,14 @@ def _data_file(root, digest):
     return os.path.join(root, digest[:2], digest)
 
 
-def _data_hasher():
+def _data_hasher(digest):
+    """A hasher of the algorithm ``digest`` names, or None where it cannot be computed here.
+
+    A digest with the ``b2-`` prefix is blake2b and one without is blake3, so a runtime
+    without blake3 cannot check a blake3 digest and trusts the sender.
+    """
+    if digest.startswith("b2-"):
+        return hashlib.blake2b(digest_size=16)
     try:
         import blake3
     except ImportError:
@@ -675,10 +682,23 @@ def _data_hasher():
     return blake3.blake3(max_threads=blake3.blake3.AUTO)
 
 
+def _data_new_hasher():
+    """The hasher this runtime names new content with: blake3 when present, else blake2b."""
+    hasher = _data_hasher("")
+    return hasher if hasher is not None else hashlib.blake2b(digest_size=16)
+
+
+def _data_finish(hasher):
+    """The digest a hasher has accumulated, with the prefix a blake2b digest carries."""
+    if hasher.name == "blake2b":
+        return "b2-" + hasher.hexdigest()
+    return hasher.hexdigest(length=16)
+
+
 def _data_commit(partial, final, digest, hasher):
     """Rename a received file into the cache once its digest matches, read-only."""
     if hasher is not None:
-        found = hasher.hexdigest(length=16)
+        found = _data_finish(hasher)
         if found != digest:
             os.remove(partial)
             raise ValueError("file blob %s arrived with digest %s" % (digest, found))
@@ -838,7 +858,7 @@ def _op_data_put(request):
         stale = _DATA_OPEN.pop(digest, None)
         if stale is not None:
             stale[0].close()
-        _DATA_OPEN[digest] = (open(partial, "wb"), _data_hasher())
+        _DATA_OPEN[digest] = (open(partial, "wb"), _data_hasher(digest))
     handle, hasher = _DATA_OPEN[digest]
     handle.write(chunk)
     if hasher is not None:
@@ -938,7 +958,7 @@ def _op_data_seal(request):
         raise ValueError(
             "file blob %s is short: %d of %d bytes arrived" % (digest, found, int(size))
         )
-    hasher = _data_hasher()
+    hasher = _data_hasher(digest)
     if hasher is not None:
         with open(partial, "rb") as handle:
             while True:
@@ -946,7 +966,7 @@ def _op_data_seal(request):
                 if not piece:
                     break
                 hasher.update(piece)
-        got = hasher.hexdigest(length=16)
+        got = _data_finish(hasher)
         if got != digest:
             os.remove(partial)
             raise ValueError("file blob %s arrived with digest %s" % (digest, got))
@@ -979,7 +999,7 @@ def _op_data_pull(request):
             partial = "%s.partial.%d.%d" % (final, os.getpid(), threading.get_ident())
             try:
                 os.makedirs(os.path.dirname(final), exist_ok=True)
-                hasher = _data_hasher()
+                hasher = _data_hasher(digest)
                 wanted = urllib.request.Request(url, headers=headers)
                 with urllib.request.urlopen(wanted, timeout=3600) as response, \
                         open(partial, "wb") as out:
@@ -2334,16 +2354,14 @@ def _op_pack_blob(request):
     directory = os.path.expanduser(request["dir"])
     os.makedirs(directory, exist_ok=True)
     partial = os.path.join(directory, ".pack.%d.partial" % os.getpid())
-    hasher = _data_hasher()
-    if hasher is None:
-        hasher = hashlib.blake2b(digest_size=16)
+    hasher = _data_new_hasher()
     try:
         with open(partial, "wb") as handle:
             hashed = _HashedFile(handle, hasher)
             mode = "w:gz" if request.get("gzip", True) else "w"
             with tarfile.open(fileobj=hashed, mode=mode) as archive:
                 archive.add(root, arcname=os.path.basename(root.rstrip("/")), recursive=True)
-        digest = hasher.hexdigest() if hasher.name == "blake2b" else hasher.hexdigest(length=16)
+        digest = _data_finish(hasher)
         final = _data_file(directory, digest)
         os.makedirs(os.path.dirname(final), exist_ok=True)
         os.replace(partial, final)

{letify-2.8.2 → letify-2.8.4}/letify/providers/colab.py

@@ -131,6 +131,26 @@ UNASSIGN_SCRIPT = (
 )
 
 
+#: Run in the CLI's own Python: ``colab`` with google-auth's request timeout raised to 600 s.
+#: The CLI passes no timeout, so a slow A100 assignment fails at the 120 s default while the
+#: server goes on assigning. google-auth binds the 120 s default into the signature of
+#: ``AuthorizedSession.request`` when it is defined, so setting the module value alone changes
+#: nothing and the method is wrapped as well. Spec "Colab", the Colab CLI paragraph.
+NEW_SCRIPT = (
+    "import sys\n"
+    "import google.auth.transport.requests as requests\n"
+    "requests._DEFAULT_TIMEOUT = 600\n"
+    "_request = requests.AuthorizedSession.request\n"
+    "def _slow_request(self, *args, **kwargs):\n"
+    "    kwargs.setdefault('timeout', requests._DEFAULT_TIMEOUT)\n"
+    "    return _request(self, *args, **kwargs)\n"
+    "requests.AuthorizedSession.request = _slow_request\n"
+    "from colab_cli.cli import main\n"
+    "sys.argv = ['colab', *sys.argv[1:]]\n"
+    "sys.exit(main())\n"
+)
+
+
 def _parse_assignments(listing: str) -> list[tuple[str, str]]:
     """The ``(name, endpoint)`` pairs in ``colab sessions`` output, ``?`` for no local state."""
     found = []
@@ -275,8 +295,21 @@ class Colab(Shell):
 
     # -- the CLI -------------------------------------------------------------
 
-    def _cli(self, *args: str, timeout: float | None = None, stdin: str | None = None) -> str:
-        command = [*self._colab(), *args]
+    def _cli(
+        self,
+        *args: str,
+        timeout: float | None = None,
+        stdin: str | None = None,
+        script: str | None = None,
+    ) -> str:
+        """Run the CLI; with ``script``, run that code in the CLI's Python with ``args`` as argv."""
+        if script is None:
+            command = [*self._colab(), *args]
+        else:
+            uv = tools.find_uv()
+            if uv is None:
+                raise ProviderUnavailable(self.kind, tools.missing_uv_message())
+            command = [*tools.python_command(tools.COLAB, uv), "-c", script, *args]
         result = subprocess.run(
             command,
             input=stdin,
@@ -286,9 +319,10 @@ class Colab(Shell):
             env=self._env(),
         )
         if result.returncode != 0:
+            shown = ["<script>" if part == script else part for part in command]
             raise RuntimeFailure(
-                f"`{' '.join(command)}` exited {result.returncode}",
-                command=" ".join(command),
+                f"`{' '.join(shown)}` exited {result.returncode}",
+                command=" ".join(shown),
                 stderr=(result.stderr or "").strip(),
             )
         return result.stdout
@@ -482,7 +516,7 @@ class Colab(Shell):
                 file=sys.stderr,
             )
         try:
-            self._cli(*args, timeout=900)
+            self._cli(*args, timeout=900, script=NEW_SCRIPT)
         except BaseException:
             # A timed out `colab new` can still leave a server-side assignment behind.
             if before is not None:

{letify-2.8.2 → letify-2.8.4}/letify/runtime/bootstrap.py

@@ -281,13 +281,15 @@ def workspace_pack_source(root: str, archive: str) -> str:
     Spec "Volumes on a persistent runtime": runs ``tar`` from the directory's parent into a
     temporary name and renames it into place, so a concurrent session never reads a half
     written archive. Uncompressed, because gzip costs more than it saves on a local volume.
+    The temporary name carries random hex, not the process id, because every Modal sandbox
+    runs its worker under the same pid. A failed pack removes its temporary file.
     """
     return (
-        "import os, subprocess\n"
+        "import os, secrets, subprocess\n"
         f"_root = os.path.expanduser({root!r}).rstrip('/')\n"
         f"_archive = os.path.expanduser({archive!r})\n"
         "os.makedirs(os.path.dirname(_archive), exist_ok=True)\n"
-        "_partial = _archive + '.' + str(os.getpid()) + '.partial'\n"
+        "_partial = _archive + '.' + secrets.token_hex(8) + '.partial'\n"
         "try:\n"
         "    subprocess.run(['tar', '-cf', _partial, '-C', os.path.dirname(_root),\n"
         "                    os.path.basename(_root)], check=True, capture_output=True)\n"

{letify-2.8.2 → letify-2.8.4}/letify/runtime/session.py

@@ -86,6 +86,13 @@ def _against_the_build(size: int, rate: float, build_s: float) -> str:
     )
 
 
+def _reason_of(error: BaseException) -> str:
+    """One line naming an error's type and first message line, for a status message."""
+    lines = str(error).strip().splitlines()
+    reason = f"{type(error).__name__}: {lines[0]}" if lines else type(error).__name__
+    return reason[:197] + "..." if len(reason) > 200 else reason
+
+
 def _sync_rather_than_restore(archive_bytes: int, rate: float, build_s: float) -> str:
     """The line explaining why a session syncs instead of restoring a cached archive.
 
@@ -243,9 +250,14 @@ class Runtime:
                 if volume.store.backend.moves_on_runtime:
                     self._start_drive_pack(volume, root)
                 else:
-                    volume.cache_env_from(
-                        self, self.env, root, platform=self.platform, build_s=self.env_build_s
-                    )
+                    try:
+                        volume.cache_env_from(
+                            self, self.env, root, platform=self.platform, build_s=self.env_build_s
+                        )
+                    except Exception as error:
+                        # The environment is built and checked, so a failed cache must not
+                        # fail the session. Spec "Materializing into a runtime".
+                        self._say(f"not caching the environment ({_reason_of(error)})")
         self.keep_blobs_on_disk()
         for volume in self.volumes:
             self.attach(volume)
@@ -826,7 +838,12 @@ class Runtime:
             "caching the environment on the workspace root"
             + (f", {size / 1_000_000_000:.1f} GB" if size else "")
         )
-        self.eval(bootstrap.workspace_pack_source(root, self._workspace_archive()), timeout=3600)
+        source = bootstrap.workspace_pack_source(root, self._workspace_archive())
+        try:
+            self.eval(source, timeout=3600)
+        except Exception as error:
+            # The environment is built and checked, so a failed cache must not fail the call.
+            self._say(f"not caching the environment on the workspace root ({_reason_of(error)})")
 
     def _environment_volumes(self) -> tuple[Volume, ...]:
         """Explicit archive volumes, or the automatic cache where the project does not survive.

{letify-2.8.2 → letify-2.8.4}/letify/store/handoff.py

@@ -248,7 +248,13 @@ def unstash(name: str, path: str | os.PathLike[str]) -> Path | None:
 
 
 def _verify(name: str, archive: Path, digest: str) -> None:
-    found = digest_of_file(archive)
+    hasher = codec.hasher_for(digest)
+    if hasher is None:
+        return
+    with open(archive, "rb") as handle:
+        while chunk := handle.read(1 << 20):
+            hasher.update(chunk)
+    found = codec.finish_digest(hasher)
     if found != digest:
         raise RuntimeFailure(
             f"handoff {name!r}: the blob downloaded from Drive has digest {found}, "

{letify-2.8.2 → letify-2.8.4}/letify/store/pathdata.py

@@ -139,9 +139,9 @@ def hash_file(path: Path, size: int) -> str:
         else:
             while chunk := handle.read(1 << 20):
                 hasher.update(chunk)
-    if hasher.name == "blake2b":
-        return hasher.hexdigest()
-    return hasher.hexdigest(length=16)
+    from ..protocol.codec import finish_digest
+
+    return finish_digest(hasher)
 
 
 class DigestCache:
@@ -1608,7 +1608,7 @@ def _get(
     Spec "Writing back". One writing thread takes the pieces, so receiving the next one
     overlaps writing and hashing the one before it and the link does not idle.
     """
-    from ..protocol.codec import _hasher
+    from ..protocol.codec import finish_digest, hasher_for
 
     # Spec "Writing back": a stream that fails after these were created would leave them
     # empty, and a resume that picks the newest directory by name then trusts a checkpoint
@@ -1617,7 +1617,8 @@ def _get(
     partial = target.with_name(
         f".{target.name}.letify-partial.{os.getpid()}.{threading.get_ident()}"
     )
-    hasher = _hasher()
+    # The algorithm the digest names, which is the worker's when its venv has no blake3.
+    hasher = hasher_for(digest)
     pieces: queue.Queue = queue.Queue(maxsize=WRITE_QUEUE)
     failure: list[BaseException] = []
 
@@ -1630,7 +1631,8 @@ def _get(
                     if piece is None:
                         return
                     handle.write(piece)
-                    hasher.update(piece)
+                    if hasher is not None:
+                        hasher.update(piece)
         except BaseException as exc:  # pragma: no cover - a local disk failure
             failure.append(exc)
             # Drained, so the receiving thread is never left waiting on a full queue.
@@ -1657,7 +1659,7 @@ def _get(
             raise RuntimeFailure(
                 f"{runtime.name}: file blob {digest} arrived with {received} bytes, not {size}"
             )
-        found = hasher.hexdigest() if hasher.name == "blake2b" else hasher.hexdigest(length=16)
+        found = finish_digest(hasher) if hasher is not None else digest
         if found != digest:
             raise RuntimeFailure(f"{runtime.name}: file blob {digest} arrived with digest {found}")
         os.replace(partial, target)

{letify-2.8.2 → letify-2.8.4}/letify/transport/nat.py

@@ -659,6 +659,31 @@ def _authorize(public_key: str) -> None:
 #: The SSH server binary the remote half starts on a machine that has none on the port.
 SSHD = "/usr/sbin/sshd"
 
+#: The image's own server configuration, which the started server's is copied from.
+SSHD_CONFIG = "/etc/ssh/sshd_config"
+
+#: The configuration the remote half starts the server with.
+LETIFY_SSHD_CONFIG = "/etc/ssh/sshd_config.letify"
+
+#: Unauthenticated connections the server takes at once. Spec "Colab": a Colab image sets 1,
+#: and the transfer streams of one session arrive together.
+SSHD_MAX_STARTUPS = "64:30:128"
+
+
+def _write_sshd_config(source: str, target: str) -> None:
+    """Copy ``source`` to ``target`` with its MaxStartups replaced by ``SSHD_MAX_STARTUPS``.
+
+    A command-line ``-o MaxStartups`` does not override the file's value, so the file the
+    server reads has to carry it.
+    """
+    try:
+        lines = Path(source).read_text().splitlines()
+    except OSError:
+        lines = []
+    kept = [line for line in lines if not line.strip().lower().startswith("maxstartups")]
+    # First, ahead of any Match block, so it applies to the whole server.
+    Path(target).write_text("\n".join([f"MaxStartups {SSHD_MAX_STARTUPS}", *kept]) + "\n")
+
 
 def _ssh_answers(port: int, timeout: float = 3.0) -> bool:
     """Whether a line starting with ``SSH-`` arrives from ``127.0.0.1:<port>``."""
@@ -691,7 +716,11 @@ def _start_sshd(port: int = 22) -> None:
     # server closes every connection before the banner. ssh-keygen -A makes only what is
     # missing, so an image that already has its keys is untouched.
     subprocess.run(["ssh-keygen", "-A"], check=False)
-    subprocess.run([SSHD, "-p", str(port), "-o", "ListenAddress=127.0.0.1"], check=False)
+    _write_sshd_config(SSHD_CONFIG, LETIFY_SSHD_CONFIG)
+    subprocess.run(
+        [SSHD, "-f", LETIFY_SSHD_CONFIG, "-p", str(port), "-o", "ListenAddress=127.0.0.1"],
+        check=False,
+    )
 
 
 def run_detached(request_json: str, source: str) -> None:  # pragma: no cover - remote entry

{letify-2.8.2 → letify-2.8.4}/letify-core/Cargo.lock

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

{letify-2.8.2 → letify-2.8.4}/letify-core/Cargo.toml

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

{letify-2.8.2 → letify-2.8.4}/letify-ext/package-lock.json

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

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

{letify-2.8.2 → letify-2.8.4}/pyproject.toml

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