letify 1.2.3__tar.gz → 1.2.4__tar.gz

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

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

{letify-1.2.3 → 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.3 → letify-1.2.4}/letify-core/Cargo.lock

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

{letify-1.2.3 → 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.3"
+version = "1.2.4"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

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

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

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

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

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

{letify-1.2.3 → 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)