letify 2.0.0__tar.gz → 2.1.0__tar.gz

{letify-2.0.0 → letify-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.0.0
+Version: 2.1.0
 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.0.0 → letify-2.1.0}/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__ = "2.0.0"
+__version__ = "2.1.0"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.0.0 → letify-2.1.0}/letify/protocol/worker.py

@@ -949,13 +949,21 @@ def _data_place_now(state, path, entry):
     except OSError:
         pass
     if not linked:
+        # Linked at a name of its own and renamed over the path, never unlinked first.
+        # Unlinking leaves the final name absent for as long as the link takes, and when
+        # the link then fails the file that was there is lost: a body that listed the
+        # directory is left with a name it cannot stat. Spec "What the body sees before a
+        # file arrives". _DATA_PARTIAL names are filtered from every patched listing.
+        staged = "%s%slink%d" % (path, _DATA_PARTIAL, os.getpid())
         try:
-            if os.path.exists(path):
-                os.remove(path)
-            os.link(source, path)
+            os.link(source, staged)
+            os.replace(staged, path)
             linked = True
         except OSError:
-            pass
+            try:
+                os.remove(staged)
+            except OSError:
+                pass
     if not linked:
         # Copied to a name of its own and renamed into place, so a reader never stats a
         # file that is half written. Spec "What the body sees before a file arrives".

{letify-2.0.0 → letify-2.1.0}/letify/providers/kaggle.py

@@ -1125,7 +1125,7 @@ class Kaggle(Provider):
         )
         return rendezvous
 
-    def target_over(self, channel: Any) -> Any:
+    def target_over(self, channel: Any, *, name: str | None = None) -> Any:
         """What the strategies need, with no address because there is none to dial."""
         from ..transport import nat
         from ..transport.strategies import Target
@@ -1133,6 +1133,9 @@ class Kaggle(Provider):
         user = self.config.option("user")
         return Target(
             alias=self.alias,
+            # Every run is a new machine whose ssh-keygen -A makes new host keys, so one
+            # alias for the account would fail every session after the first.
+            host_key_alias=f"letify-{self.alias}-{name}" if name else None,
             rendezvous=self.rendezvous_over(channel),
             remote_python=self.remote_python,
             stun=nat.DEFAULT_STUN,
@@ -1149,12 +1152,12 @@ class Kaggle(Provider):
 
         return [TCPPunch(), TailcatUDP(), QuicUDP(), ProviderFallback(rank=6)]
 
-    def link_over(self, channel: Any) -> Any:
+    def link_over(self, channel: Any, *, name: str | None = None) -> Any:
         """Race the strategies over the bridge and return the link that wins."""
         from ..transport.announce import printer
         from ..transport.pipeline import LinkCache, Pipeline, network_fingerprint
 
-        target = self.target_over(channel)
+        target = self.target_over(channel, name=name)
         return Pipeline(
             self.strategies(),
             target=target,
@@ -1195,7 +1198,7 @@ class Kaggle(Provider):
         from ..runtime.channel import PersistentChannel
 
         try:
-            link = self.link_over(bridge)
+            link = self.link_over(bridge, name=name)
         except Exception:
             return bridge
         self._links[name] = link

{letify-2.0.0 → letify-2.1.0}/letify/transport/probe.py

@@ -1,8 +1,8 @@
 """Probe, a short measurement of a Link.
 
-Owns the client side of the probe: 30 round trips, then a timed transfer in each
-direction against the responder in ``nat.serve_probe``. It does not own what the numbers
-decide; the pipeline does.
+Owns the client side of the probe: 30 round trips, then a discarded warm-up and a timed
+transfer in each direction against the responder in ``nat.serve_probe``. It does not own
+what the numbers decide; the pipeline does.
 """
 
 from __future__ import annotations
@@ -38,8 +38,19 @@ class ProbeResult:
         return cls(float(data["rtt_ms"]), float(data["upload_bps"]), float(data["download_bps"]))
 
 
+#: Round trips of warm-up before the measured transfer, and the bounds on it in seconds.
+WARMUP_ROUND_TRIPS = 8
+WARMUP_MIN_S = 0.5
+WARMUP_MAX_S = 2.0
+
+
 class Probe:
-    """30 round trips, then ``seconds`` of transfer each way. Durations are injectable."""
+    """30 round trips, a discarded warm-up, then ``seconds`` of transfer each way.
+
+    The warm-up exists because TCP's ramp is fixed in round trips while the measurement
+    window is fixed in seconds, so without it a far link is charged for its own slow
+    start and reports the ramp average. Spec "Choosing a link". Durations are injectable.
+    """
 
     def __init__(
         self,
@@ -52,6 +63,11 @@ class Probe:
         self.seconds = seconds
         self.clock = clock
 
+    def warmup_for(self, rtt_ms: float) -> float:
+        """Seconds of transfer to discard before measuring, from the round trip."""
+        wanted = WARMUP_ROUND_TRIPS * rtt_ms / 1000.0
+        return min(WARMUP_MAX_S, max(WARMUP_MIN_S, wanted))
+
     def measure(self, stream: Stream) -> ProbeResult:
         rtts = []
         for index in range(self.round_trips):
@@ -61,26 +77,36 @@ class Probe:
             if nat.recv_exact(stream, 9) != b"P" + payload:
                 raise OSError("the probe responder answered out of order")
             rtts.append((self.clock() - began) * 1000.0)
+        rtt_ms = statistics.median(rtts) if rtts else 0.0
+
+        # The warm-up runs on the same connection, so the window it opens carries over.
+        warmup = self.warmup_for(rtt_ms)
+        self._upload(stream, warmup)
+        upload = self._upload(stream, self.seconds)
+        self._download(stream, warmup)
+        download = self._download(stream, self.seconds)
+        return ProbeResult(rtt_ms, upload, download)
 
+    def _upload(self, stream: Stream, seconds: float) -> float:
         block = b"\0" * nat.CHUNK
         stream.sendall(b"U")
         began = self.clock()
-        while self.clock() - began < self.seconds:
+        while self.clock() - began < seconds:
             stream.sendall(struct.pack("!I", len(block)) + block)
         stream.sendall(struct.pack("!I", 0))
         received = struct.unpack("!Q", nat.recv_exact(stream, 8))[0]
-        upload = received / max(self.clock() - began, 1e-9)
+        return received / max(self.clock() - began, 1e-9)
 
+    def _download(self, stream: Stream, seconds: float) -> float:
         began = self.clock()
-        stream.sendall(b"D" + struct.pack("!d", self.seconds))
+        stream.sendall(b"D" + struct.pack("!d", seconds))
         total = 0
         while True:
             size = struct.unpack("!I", nat.recv_exact(stream, 4))[0]
             if size == 0:
                 break
             total += len(nat.recv_exact(stream, size))
-        download = total / max(self.clock() - began, 1e-9)
-        return ProbeResult(statistics.median(rtts) if rtts else 0.0, upload, download)
+        return total / max(self.clock() - began, 1e-9)
 
 
 __all__ = ["Probe", "ProbeResult", "Stream"]

{letify-2.0.0 → letify-2.1.0}/letify-core/Cargo.lock

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

{letify-2.0.0 → letify-2.1.0}/letify-core/Cargo.toml

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

{letify-2.0.0 → letify-2.1.0}/letify-ext/package-lock.json

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

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

{letify-2.0.0 → letify-2.1.0}/pyproject.toml

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

{letify-2.0.0 → letify-2.1.0}/tests/test_data_streaming.py

@@ -15,6 +15,7 @@ from __future__ import annotations
 
 import collections
 import re
+import threading
 import time
 from pathlib import Path
 
@@ -752,10 +753,28 @@ def test_a_blob_that_never_arrives_fails_the_open(
 
 
 def test_a_call_that_returns_early_cancels_the_transfer(
-    launcher_from, project, capsys
+    launcher_from, project, capsys, monkeypatch
 ) -> None:
+    # Spec "A call that finishes before the background transfer". Each piece sent after
+    # the call request waits 50 ms, so the cancellation is certain to arrive while the
+    # transfer is still running. Without that the test asserts a timing accident: on a
+    # local channel all 23 MiB can go out in 0.1 s, before the body has even returned,
+    # and nothing is left to cancel. It failed that way in 2 of 4 runs pinned to two
+    # cores, which is what CI runs on.
     let = streaming(launcher_from, data_first_wave_files=1)
     root = dataset(project, 24, size=1 << 20)
+    calling = threading.Event()
+    original_message = wire.Sender.message
+
+    def message(self_, kind, stream, obj):
+        if kind == wire.REQUEST and isinstance(obj, dict):
+            if obj.get("op") == "call":
+                calling.set()
+            elif obj.get("op") == "data_put" and calling.is_set():
+                time.sleep(0.05)
+        return original_message(self_, kind, stream, obj)
+
+    monkeypatch.setattr(wire.Sender, "message", message)
 
     @let.function(device=let.providers.lab.CPU, host=letify.remote)
     def peek(directory: Path) -> str:

{letify-2.0.0 → letify-2.1.0}/tests/test_kaggle_link.py

@@ -131,7 +131,7 @@ def test_a_chosen_link_becomes_the_channel(monkeypatch) -> None:
             built.append(command)
             self.name = name
 
-    monkeypatch.setattr(provider, "link_over", lambda channel: Link())
+    monkeypatch.setattr(provider, "link_over", lambda channel, name=None: Link())
     monkeypatch.setattr("letify.runtime.channel.PersistentChannel", Fake)
     channel = provider.channel_over(Channel(), name="k-1")
     assert isinstance(channel, Fake)
@@ -230,3 +230,16 @@ def test_the_kaggle_punch_target_logs_in_as_root_with_the_authorized_key(tmp_pat
     command = target.forwarded_ssh(40000, "python3 -c pass")
     assert "root@127.0.0.1" in command
     assert command[command.index("-i") + 1] == str(key)
+
+
+def test_a_kaggle_runtime_pins_its_host_key_under_its_own_alias() -> None:
+    """Spec "Kaggle runtimes", An SSH link over the kernel: each run is a new machine.
+
+    One alias for the account fails every session after the first with REMOTE HOST
+    IDENTIFICATION HAS CHANGED, because ssh-keygen -A makes new host keys on each VM.
+    """
+    provider = kaggle()
+    target = provider.target_over(object(), name="letify-cpu-abc123")
+    assert target.host_key_alias == "letify-kaggle_a-letify-cpu-abc123"
+    command = target.forwarded_ssh(40000)
+    assert command[command.index("HostKeyAlias=letify-kaggle_a-letify-cpu-abc123")]

{letify-2.0.0 → letify-2.1.0}/tests/test_transport.py

@@ -224,6 +224,46 @@ def test_the_probe_defaults_are_thirty_round_trips_and_two_seconds_each_way() ->
     assert (probe.round_trips, probe.seconds) == (30, 2.0)
 
 
+def test_the_warm_up_is_eight_round_trips_bounded_to_half_a_second_and_two() -> None:
+    # Spec "Choosing a link": long enough for TCP to leave slow start, and no longer.
+    probe = Probe()
+    assert probe.warmup_for(0.0) == 0.5
+    assert probe.warmup_for(10.0) == 0.5
+    assert probe.warmup_for(190.0) == pytest.approx(1.52)
+    assert probe.warmup_for(1000.0) == 2.0
+
+
+def test_the_probe_discards_a_warm_up_transfer_in_each_direction() -> None:
+    """Spec "Choosing a link": the measured transfer is not charged for the ramp.
+
+    The responder is asked to transfer four times, a warm-up and a measurement each way.
+    Only the measured ones decide the numbers, so a stream that is slow until it is warm
+    reports its warm rate.
+    """
+    user, remote = socket.socketpair()
+    threading.Thread(target=nat.serve_probe, args=(remote,), daemon=True).start()
+    probe = Probe(round_trips=2, seconds=0.02)
+    probe.warmup_for = lambda _rtt_ms: 0.02
+    seen: list[bytes] = []
+
+    class Watched:
+        """The stream, recording which transfer ops the probe asked for."""
+
+        def recv(self, size: int) -> bytes:
+            return user.recv(size)
+
+        def sendall(self, data: bytes) -> None:
+            if data[:1] in (b"U", b"D"):
+                seen.append(data[:1])
+            user.sendall(data)
+
+    measured = probe.measure(Watched())
+    user.close()
+    assert seen == [b"U", b"U", b"D", b"D"]
+    assert measured.upload_bps > 0
+    assert measured.download_bps > 0
+
+
 def test_a_responder_asked_to_bridge_stops_answering_the_probe() -> None:
     user, remote = socket.socketpair()
     user.sendall(b"B")