letify 2.6.4__tar.gz → 2.6.5__tar.gz

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

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

@@ -1063,6 +1063,16 @@ less time than the build did. The archive is smaller than the directory, so the
 overstates the transfer and errs toward building, which is the cheaper of the two to get wrong. The
 ref records the build seconds beside the archive.
 
+With no measured rate for the link, letify packs only when that directory is at most 1 GiB, and says
+why when it declines. Packing moves the archive as one payload that the worker and the client each
+hold whole, so a tree of several gigabytes is held twice in memory with nothing reporting progress:
+measured on a Modal A10, a 7.2 GB environment sat in that step for over 30 minutes while the session
+billed. Packing unconditionally was right while only an ephemeral provider packed, where the
+alternative was a certain full rebuild; a provider that keeps its workspace root and builds its venv
+elsewhere reaches the same branch, and there the alternative is a sync that may take two minutes.
+Making the pack stream rather than hold the archive whole is the fix that removes this limit, and
+until then the limit is what keeps the step from costing more than it saves.
+
 A later session restores only when the archive's size over the link measured for that session would
 take less than the recorded build. Otherwise it syncs, and says why:
 `letify: <runtime>: syncing rather than restoring, because 3.0 GB over 13.6 MiB/s is 210 s against a
@@ -1076,7 +1086,9 @@ 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.
 
-Skipping the pack is said too, because it is a decision letify made rather than a thing that did not
+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
 happen: `letify: <runtime>: not caching the environment, because 9.4 GB over 13.6 MiB/s is 659 s
 against a 34 s build`.
 

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

{letify-2.6.4 → letify-2.6.5}/letify/runtime/session.py

@@ -47,6 +47,11 @@ if TYPE_CHECKING:
 #: The total size of argument blob files kept under a persistent workspace root, 32 GiB.
 BLOB_DISK_LIMIT = 32 * 1024**3
 
+#: The largest project directory letify packs into an environment archive when it has no
+#: measured rate to judge the transfer by. Spec "Materializing into a runtime": the pack
+#: moves the archive as one payload the worker and the client each hold whole.
+PACK_WITHOUT_A_RATE = 1024**3
+
 
 def _against_the_build(size: int, rate: float, build_s: float) -> str:
     """The three numbers both cache decisions weigh, as they are reported.
@@ -185,6 +190,11 @@ class Runtime:
                 self.provider.env_root or self.workspace or self.provider.workspace_root, self.env
             )
             if self._worth_packing(root):
+                size = self._tree_size(root)
+                self._say(
+                    "caching the environment"
+                    + (f", {size / 1_000_000_000:.1f} GB" if size else "")
+                )
                 self._environment_volumes()[0].cache_env_from(
                     self, self.env, root, platform=self.platform, build_s=self.env_build_s
                 )
@@ -687,25 +697,38 @@ class Runtime:
             return None
         return float(rate)
 
+    def _tree_size(self, root: str) -> int | None:
+        """The byte size of the project directory on the runtime, or None when unknown."""
+        from . import bootstrap
+
+        try:
+            size = self.eval(bootstrap.tree_size_source(root), timeout=120)
+        except Exception:
+            return None
+        return size if isinstance(size, int) and size > 0 else None
+
     def _worth_packing(self, root: str) -> bool:
         """Whether moving the project directory over this session's link beats the build.
 
         Spec "Materializing into a runtime": the directory is larger than the archive it
-        would become, so this overstates the transfer and errs toward building. A session
-        with no measured rate packs unconditionally, as it always did.
+        would become, so this overstates the transfer and errs toward building. With no
+        measured rate it packs only what letify is willing to hold in memory, because the
+        pack moves the archive as one payload the worker and the client each hold whole.
         """
         if self.env_build_s is None:
             return True
         rate = self._measured_rate()
+        size = self._tree_size(root)
         if rate is None:
-            return True
-        from . import bootstrap
-
-        try:
-            size = self.eval(bootstrap.tree_size_source(root), timeout=120)
-        except Exception:
-            return True
-        if not isinstance(size, int) or size <= 0:
+            if size is None or size <= PACK_WITHOUT_A_RATE:
+                return True
+            self._say(
+                f"not caching the environment, because {size / 1_000_000_000:.1f} GB is over "
+                f"the {PACK_WITHOUT_A_RATE / 1024**3:.1f} GiB letify will hold in memory and "
+                f"this link was never measured"
+            )
+            return False
+        if size is None:
             return True
         if (size / rate) < self.env_build_s:
             return True

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

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

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

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

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

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

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

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

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

{letify-2.6.4 → letify-2.6.5}/tests/test_runtime.py

@@ -2593,3 +2593,57 @@ def test_a_persistent_provider_that_builds_its_venv_elsewhere_still_archives(
     finally:
         runtime.shutdown()
     assert volume.cached_env(env, platform), "nothing was archived, so the next session resyncs"
+
+
+def test_a_large_environment_is_not_packed_when_the_link_was_never_measured(
+    uv_project: Path, tmp_path: Path, monkeypatch, capsys
+) -> None:
+    """Spec "Materializing into a runtime": the pack holds the archive whole, twice.
+
+    2.6.3 made a provider that keeps its workspace root archive like an ephemeral one, and
+    that branch packed unconditionally with no measured rate. On a Modal A10 a 7.2 GB
+    environment sat in the pack for over 30 minutes, silently, while the session billed.
+    """
+    from letify.runtime import session as sessionmod
+
+    provider = provider_of(PreparingLocal, "lab", persistent=False)
+    volume = provider.volume(
+        "cache", backend="filesystem", root=str(tmp_path / "store"), mount=str(tmp_path / "mount")
+    )
+    env = Env()
+    instance = Instance(provider, gpu=None)._placed("remote")
+    # No measured rate, as a Modal sandbox has none, and a tree over the limit.
+    monkeypatch.setattr(sessionmod.Runtime, "_measured_rate", lambda self: None)
+    monkeypatch.setattr(
+        sessionmod.Runtime, "_tree_size", lambda self, root: 8 * 1024**3
+    )
+    runtime = provider.start(instance, env, name="lab-1", volumes=(volume,))
+    try:
+        platform = runtime.platform
+    finally:
+        runtime.shutdown()
+    assert volume.cached_env(env, platform) is None
+    err = capsys.readouterr().err
+    assert "over the 1.0 GiB letify will hold in memory" in err, err
+
+
+def test_a_small_environment_is_still_packed_and_says_so(
+    uv_project: Path, tmp_path: Path, monkeypatch, capsys
+) -> None:
+    """Spec "Materializing into a runtime": the pack can take minutes, so it is said."""
+    from letify.runtime import session as sessionmod
+
+    provider = provider_of(PreparingLocal, "lab", persistent=False)
+    volume = provider.volume(
+        "cache", backend="filesystem", root=str(tmp_path / "store"), mount=str(tmp_path / "mount")
+    )
+    env = Env()
+    instance = Instance(provider, gpu=None)._placed("remote")
+    monkeypatch.setattr(sessionmod.Runtime, "_measured_rate", lambda self: None)
+    runtime = provider.start(instance, env, name="lab-1", volumes=(volume,))
+    try:
+        platform = runtime.platform
+    finally:
+        runtime.shutdown()
+    assert volume.cached_env(env, platform)
+    assert "caching the environment" in capsys.readouterr().err