letify 1.2.2__tar.gz → 1.2.4__tar.gz

{letify-1.2.2 → letify-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 1.2.2
+Version: 1.2.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-1.2.2 → letify-1.2.4}/letify/__init__.py

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

{letify-1.2.2 → letify-1.2.4}/letify/store/volume.py

@@ -89,14 +89,18 @@ def environment_volume(provider: Provider) -> Volume:
     """The automatic environment store when an ephemeral declaration names no volumes.
 
     Spec "Materializing into a runtime": reuse the account's data bucket, or keep the
-    archive on the client without requiring a bucket or a volume declaration.
+    archive on the client without requiring a bucket or a volume declaration. The client
+    store is the declared ``~/.letify/cache/storage/<name>`` root with the name
+    ``environments``, so it stays under the single local root while still reading archives
+    an earlier install left under ``~/.cache/letify/environments``.
     """
+    from ..paths import storage_cache_directory
     from .backends.filesystem import FilesystemBackend
     from .pathdata import data_bucket
 
     backend = data_bucket(provider)
     if backend is None:
-        root = Path.home() / ".cache" / "letify" / "environments" / provider.kind / provider.alias
+        root = storage_cache_directory("environments") / provider.kind / provider.alias
         backend = FilesystemBackend(root)
     return Volume(provider, "environments", _store=Store(backend))
 

{letify-1.2.2 → letify-1.2.4}/letify/transport/nat.py

@@ -382,11 +382,10 @@ def begin(request: dict):
             stderr=subprocess.STDOUT,
             text=True,
         )
-        for line in process.stdout:
-            found = re.search(r"address:\s*(tc\S+)", line)
-            if found:
-                return {"address": found.group(1)}, process.wait
-        raise RuntimeError("tailcat serve exited without printing its address")
+        address = _match_then_drain(process, process.stdout, r"address:\s*(tc\S+)")
+        if address is None:
+            raise RuntimeError("tailcat serve exited without printing its address")
+        return {"address": address}, process.wait
     if kind == "reverse_ssh":
         # The directory is under the account's workspace root, which may start with ~.
         key = Path(os.path.expanduser(request["key_directory"])) / "letify_reverse"
@@ -405,14 +404,47 @@ def begin(request: dict):
             stderr=subprocess.PIPE,
             text=True,
         )  # fmt: skip
-        for line in process.stderr:
-            found = re.search(r"Allocated port (\d+)", line)
-            if found:
-                return {"port": int(found.group(1))}, process.wait
-        raise RuntimeError("ssh -R exited without allocating a port")
+        allocated = _match_then_drain(process, process.stderr, r"Allocated port (\d+)")
+        if allocated is None:
+            raise RuntimeError("ssh -R exited without allocating a port")
+        return {"port": int(allocated)}, process.wait
     raise ValueError(f"unknown rendezvous request {kind!r}")
 
 
+def _match_then_drain(process, stream, pattern: str) -> str | None:
+    """First capture of ``pattern`` in ``stream``, then keep draining it in the background.
+
+    A helper letify starts and reads one line from keeps writing afterwards. Its pipe holds
+    about 64 KiB, so once nobody reads it the helper blocks on its next write and stops
+    moving bytes. ``tailcat serve`` carries the SSH connection itself, so that stall shows
+    up as a link that connects and then measures far below the link underneath it. Reading
+    on and discarding keeps the writer running, and keeps ``process.wait`` from deadlocking
+    against a full pipe.
+
+    Returns None when the stream ends before the pattern appears.
+    """
+    expression = re.compile(pattern)
+    found = None
+    for line in stream:
+        match = expression.search(line)
+        if match:
+            found = match.group(1)
+            break
+    if found is None:
+        return None
+
+    def drain() -> None:
+        try:
+            for _ in stream:
+                pass
+        except (OSError, ValueError):
+            # The process ended and the stream was closed under us, which is the normal end.
+            pass
+
+    threading.Thread(target=drain, name="letify-drain", daemon=True).start()
+    return found
+
+
 def _authorize(public_key: str) -> None:
     path = Path.home() / ".ssh" / "authorized_keys"
     path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)

{letify-1.2.2 → letify-1.2.4}/letify/transport/pipeline.py

@@ -40,6 +40,15 @@ DEFAULT_MIN_MIB_PER_S = 10.0
 DEFAULT_MAX_RTT_MS = 300.0
 
 
+class _BelowFloor(ProviderUnavailable):
+    """Every connected strategy measured below the floor.
+
+    Spec "Choosing a link": this does not end the race, because a strategy still
+    connecting may clear the floor. The race raises it only once nothing is left to wait
+    for, and it reaches the caller as the ``ProviderUnavailable`` it is.
+    """
+
+
 @dataclass(frozen=True)
 class LinkFloor:
     """The slowest link an account accepts. A probe below this fails the connection."""
@@ -402,43 +411,86 @@ class Pipeline:
 
         probed = {i for i, s in enumerate(applicable) if getattr(s, "probed", True)}
         deadline = time.monotonic() + self.timeout
+        held = {s.name for s in applicable if not getattr(s, "probed", True)}
+        #: Strategies already offered to _choose, so a later round considers only new ones.
+        seen: set[int] = set()
+        rejected: _BelowFloor | None = None
+
+        # Spec "Choosing a link": the race is not over until a link is accepted. A round
+        # that ends with every connected strategy below the floor drops the grace period
+        # and waits out the rest of the timeout for the strategies still connecting.
+        while True:
+            with condition:
+                while len(outcomes) < len(applicable):
+                    fresh = [
+                        index
+                        for index, outcome in outcomes.items()
+                        if index not in seen and not isinstance(outcome, Exception)
+                    ]
+                    if state["first"] is None and probed <= outcomes.keys() and fresh:
+                        # Every probed strategy failed, so an unprobed one is all that is left.
+                        break
+                    now = time.monotonic()
+                    limit = deadline if state["first"] is None else state["first"] + self.grace
+                    if now >= limit:
+                        break
+                    condition.wait(limit - now)
+                settled = dict(outcomes)
+
+            connected = []
+            for index, strategy in enumerate(applicable):
+                if index in seen or index not in settled:
+                    continue
+                seen.add(index)
+                outcome = settled[index]
+                if isinstance(outcome, Exception):
+                    reasons.append(f"{strategy.name}: {outcome}")
+                else:
+                    connected.append(outcome)
+
+            if connected:
+                connected.sort(key=lambda link: link.rank)
+                try:
+                    chosen, measured = self._choose(connected, reasons, held)
+                except _BelowFloor as below:
+                    rejected = below
+                else:
+                    with condition:
+                        state["decided"] = True
+                    for index, event in enumerate(cancels):
+                        if index not in seen:
+                            event.set()
+                    self._report_unsettled(applicable, seen, reasons)
+                    first = state["first_name"]
+                    if first is not None and first != chosen.strategy:
+                        self._say(f"switching from {first} to {chosen.strategy}")
+                    return chosen, measured
+
+            if len(seen) == len(applicable) or time.monotonic() >= deadline:
+                break
+            # Nothing acceptable yet, so the strategies still connecting get the rest of
+            # the timeout rather than the grace period that a rejected link started.
+            with condition:
+                state["first"] = None
+                state["first_name"] = None
+
         with condition:
-            while len(outcomes) < len(applicable):
-                connected = [i for i, o in outcomes.items() if not isinstance(o, Exception)]
-                if state["first"] is None and probed <= outcomes.keys() and connected:
-                    # Every probed strategy failed, so an unprobed one is all that is left.
-                    break
-                now = time.monotonic()
-                limit = deadline if state["first"] is None else state["first"] + self.grace
-                if now >= limit:
-                    break
-                condition.wait(limit - now)
             state["decided"] = True
-            settled = dict(outcomes)
         for index, event in enumerate(cancels):
-            if index not in settled:
+            if index not in seen:
                 event.set()
-
-        connected = []
+        self._report_unsettled(applicable, seen, reasons)
+        if rejected is not None:
+            raise rejected
+        self._say("no strategy connected")
+        raise ProviderUnavailable("shell", self._explain(reasons))
+
+    def _report_unsettled(self, applicable: list[Any], seen: set[int], reasons: list[str]) -> None:
+        """Name every strategy that had not connected when the choice was made."""
         for index, strategy in enumerate(applicable):
-            outcome = settled.get(index)
-            if outcome is None:
+            if index not in seen:
                 reasons.append(f"{strategy.name}: did not connect in time")
                 self._say(f"{strategy.name} timed out: not connected when the choice was made")
-            elif isinstance(outcome, Exception):
-                reasons.append(f"{strategy.name}: {outcome}")
-            else:
-                connected.append(outcome)
-        if not connected:
-            self._say("no strategy connected")
-            raise ProviderUnavailable("shell", self._explain(reasons))
-        connected.sort(key=lambda link: link.rank)
-        held = {s.name for s in applicable if not getattr(s, "probed", True)}
-        chosen, measured = self._choose(connected, reasons, held)
-        first = state["first_name"]
-        if first is not None and first != chosen.strategy:
-            self._say(f"switching from {first} to {chosen.strategy}")
-        return chosen, measured
 
     def _measure(self, link: Any) -> ProbeResult | None:
         """Probe a link and print the numbers. None when the link cannot carry the probe."""
@@ -470,7 +522,7 @@ class Pipeline:
                 measured = None
             if measured is None and floored_out:
                 _close(link)
-                raise ProviderUnavailable("shell", self._explain(reasons))
+                raise _BelowFloor("shell", self._explain(reasons))
             if link.strategy in held:
                 self._fall_back(link)
             else:
@@ -480,7 +532,8 @@ class Pipeline:
                         below = f"{link.strategy}: below the floor: {', '.join(floored)}"
                         self._say(f"rejected {below}")
                         _close(link)
-                        raise ProviderUnavailable("shell", self._explain([*reasons, below]))
+                        reasons.append(below)
+                        raise _BelowFloor("shell", self._explain(reasons))
                 self._say(f"chose {link.strategy}: only one connected")
             return link, measured
 
@@ -502,7 +555,9 @@ class Pipeline:
             floored = self.floor.violations(measured)
             if floored:
                 self._say(f"rejected {link.strategy}: below the floor: {', '.join(floored)}")
-                floored_out.append(f"{link.strategy}: below the floor: {', '.join(floored)}")
+                below = f"{link.strategy}: below the floor: {', '.join(floored)}"
+                floored_out.append(below)
+                reasons.append(below)
                 _close(link)
             else:
                 above_floor.append((link, measured))
@@ -534,8 +589,8 @@ class Pipeline:
             for link in unprobed:
                 _close(link)
             self._say("every probe was below the floor")
-            raise ProviderUnavailable(
-                "shell", self._explain([*reasons, "every probe was below the floor", *floored_out])
+            raise _BelowFloor(
+                "shell", self._explain([*reasons, "every probe was below the floor"])
             )
         elif unprobed:
             chosen, measured = unprobed[0], None

{letify-1.2.2 → letify-1.2.4}/letify-core/Cargo.lock

@@ -10,7 +10,7 @@ checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
 
 [[package]]
 name = "letify-agent"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "letify-wire",
  "libloading",
@@ -18,14 +18,14 @@ dependencies = [
 
 [[package]]
 name = "letify-driver"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "letify-wire",
 ]
 
 [[package]]
 name = "letify-wire"
-version = "1.2.2"
+version = "1.2.4"
 
 [[package]]
 name = "libloading"

{letify-1.2.2 → letify-1.2.4}/letify-core/Cargo.toml

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

{letify-1.2.2 → letify-1.2.4}/letify-ext/package-lock.json

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

{letify-1.2.2 → letify-1.2.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": "1.2.2",
+  "version": "1.2.4",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-1.2.2 → letify-1.2.4}/pyproject.toml

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

{letify-1.2.2 → letify-1.2.4}/tests/conftest.py

@@ -158,6 +158,13 @@ def uv_project(tmp_path: Path, monkeypatch) -> Path:
         subprocess.run([uv, "lock"], cwd=project, capture_output=True, check=True)
     monkeypatch.chdir(project)
     monkeypatch.setattr(bootstrap, "DEFAULT_WORKSPACE_ROOT", str(tmp_path / "runtime-workspace"))
+    # The automatic environment archive store lives under the user's own ~/.letify, so
+    # without this an archive a previous run published is found and a test that expects a
+    # sync sees "archive" instead. Spec "Materializing into a runtime".
+    from letify import paths
+
+    store = tmp_path / "storage"
+    monkeypatch.setattr(paths, "storage_cache_directory", lambda name: store / name)
     return project
 
 

{letify-1.2.2 → letify-1.2.4}/tests/test_link_log.py

@@ -6,9 +6,11 @@ Strategies and probes are the fakes from conftest, so delays and numbers are con
 
 from __future__ import annotations
 
+import pytest
 from conftest import FakeProbe, FakeStrategy
 
 import letify
+from letify.errors import ProviderUnavailable
 from letify.transport.pipeline import Fingerprint, LinkCache, LinkFloor, Pipeline
 from letify.transport.probe import ProbeResult
 
@@ -192,3 +194,32 @@ def test_a_quiet_launcher_prints_no_connection_lines(config_file, capsys) -> Non
     letify.Launcher(config_file(body), home=False, announce=False).provider("lab").connect()
     captured = capsys.readouterr()
     assert (captured.out, captured.err) == ("", "")
+
+
+# -- Spec: Choosing a link, the race is not over until a link is accepted ----------
+
+
+def test_a_strategy_rejected_by_the_floor_does_not_end_the_race() -> None:
+    # The reported Colab run: tcp_punch connected at 10.7 s and was rejected by the floor,
+    # and tailcat connected 2 s later and was closed unprobed, so the connection failed
+    # although tailcat was acceptable. Spec "Choosing a link".
+    floor = LinkFloor(min_bps=10 * MIB, max_rtt_ms=300.0)
+    punch = FakeStrategy("tcp_punch", 2, delay=0.05, result=result(8.1, 0.2, rtt=138.0))
+    tailcat = FakeStrategy("tailcat", 3, delay=0.45, result=result(24.0, 20.0))
+
+    chosen = pipeline([punch, tailcat], grace=0.2, floor=floor).connect()
+
+    assert chosen.strategy == "tailcat"
+
+
+def test_the_connection_still_fails_when_the_later_strategy_is_also_below_the_floor() -> None:
+    # Spec "Choosing a link": waiting longer is not accepting less. Every strategy settles
+    # below the floor, so the connection fails and names both rejections.
+    floor = LinkFloor(min_bps=10 * MIB, max_rtt_ms=300.0)
+    punch = FakeStrategy("tcp_punch", 2, delay=0.05, result=result(8.1, 0.2, rtt=138.0))
+    tailcat = FakeStrategy("tailcat", 3, delay=0.45, result=result(4.0, 0.1))
+
+    with pytest.raises(ProviderUnavailable) as raised:
+        pipeline([punch, tailcat], grace=0.2, floor=floor).connect()
+
+    assert "tcp_punch" in str(raised.value) and "tailcat" in str(raised.value)

{letify-1.2.2 → letify-1.2.4}/tests/test_paths.py

@@ -302,3 +302,38 @@ def test_compatibility_fallbacks_for_migrated_paths(
     Colab(ProviderConfig("colab_compat", "colab", {}, 0))
     # It should find the token via fallback
     assert (acct / ".config" / "colab-cli" / "token.json").is_file()
+
+
+# -- Spec: Local machine, the filesystem storage backend root ----------------------
+
+
+def test_the_automatic_environment_store_sits_under_the_declared_cache(monkeypatch, tmp_path):
+    # Spec "Materializing into a runtime": the automatic archive store is the
+    # ~/.letify/cache/storage/<name> row with the name "environments", not a directory of
+    # its own under ~/.cache.
+    from letify.config.schema import ProviderConfig
+    from letify.providers.local import Local
+    from letify.store.volume import environment_volume
+
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: tmp_path))
+    provider = Local(ProviderConfig("lab", "local", {}, 0))
+    volume = environment_volume(provider)
+    root = volume._store.backend.root
+
+    assert root == tmp_path / ".letify" / "cache" / "storage" / "environments" / "local" / "lab"
+    assert ".cache" not in root.parts
+
+
+def test_an_existing_environment_store_outside_the_root_is_still_read(monkeypatch, tmp_path):
+    # Spec "Materializing into a runtime": archives an earlier install left under
+    # ~/.cache/letify/environments are read rather than abandoned.
+    from letify.config.schema import ProviderConfig
+    from letify.providers.local import Local
+    from letify.store.volume import environment_volume
+
+    legacy = tmp_path / ".cache" / "letify" / "environments"
+    legacy.mkdir(parents=True)
+    monkeypatch.setattr(Path, "home", staticmethod(lambda: tmp_path))
+    provider = Local(ProviderConfig("lab", "local", {}, 0))
+
+    assert environment_volume(provider)._store.backend.root == legacy / "local" / "lab"

{letify-1.2.2 → letify-1.2.4}/tests/test_strategies.py

@@ -592,3 +592,40 @@ def test_the_remote_half_starts_no_sshd_when_an_ssh_server_already_answers(
     finally:
         server.close()
     assert not any(str(binary) in command for command in recorder.commands)
+
+
+def _flooding_binary(directory, address: str, bytes_after: int) -> str:
+    """An executable that prints ``address`` the way tailcat does, then floods its output."""
+    import os
+    import sys
+    from pathlib import Path
+
+    path = Path(directory) / "flooding_tailcat"
+    path.write_text(
+        f"#!{sys.executable}\n"
+        "import sys\n"
+        f"print('Server listening with new address: {address}', flush=True)\n"
+        f"sys.stdout.write('x' * {bytes_after})\n"
+        "sys.stdout.flush()\n"
+    )
+    path.chmod(0o755)
+    return os.fspath(path)
+
+
+def test_the_remote_half_keeps_reading_what_tailcat_serve_prints_after_the_address(
+    tmp_path,
+) -> None:
+    # A pipe holds about 64 KiB, so a megabyte is far past the point where an unread
+    # pipe blocks the writer and the tunnel stops moving bytes.
+    binary = _flooding_binary(tmp_path, "tcReal1", 1 << 20)
+    answer, serve = nat.begin({"kind": "tailcat", "ssh_port": 22, "binary": binary})
+    assert answer == {"address": "tcReal1"}
+
+    import threading
+
+    waiter = threading.Thread(target=serve, daemon=True)
+    waiter.start()
+    waiter.join(30.0)
+    assert not waiter.is_alive(), (
+        "tailcat serve never finished, so it blocked writing to a pipe nobody reads"
+    )