letify 1.2.0__tar.gz → 1.2.1__tar.gz

{letify-1.2.0 → letify-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 1.2.0
+Version: 1.2.1
 Summary: Declarations that become infrastructure.
 Project-URL: Homepage, https://github.com/DarkPyonix/letify
 Project-URL: Documentation, https://github.com/DarkPyonix/letify/tree/main/docs
@@ -192,6 +192,7 @@ Each command writes two files. The account goes to `~/.letify/config.toml`, whic
 [colab_pro_plus]
 kind = "colab"
 account = "you@example.com"
+min_mib_per_s = 0.05
 
 [lab_a100]
 kind = "shell"
@@ -201,6 +202,8 @@ key = "~/.ssh/id_ed25519"
 persistent = true
 ```
 
+The connection pipeline defaults to `10 MiB/s` in each direction and `300 ms` RTT. Colab's measured sustained best is `8.8 MiB/s` up and `10.7 MiB/s` down, so it fails the default floor. The account example explicitly permits a slow link with `min_mib_per_s = 0.05`. Set `min_mib_per_s` and `max_rtt_ms` for your measurements. When all measured links fail the floor, the connection is refused even if an unprobed fallback connected.
+
 The project's `.letify/config.toml` gets only the alias, which is what makes the account usable in this project:
 
 ```toml

{letify-1.2.0 → letify-1.2.1}/README.md

@@ -167,6 +167,7 @@ Each command writes two files. The account goes to `~/.letify/config.toml`, whic
 [colab_pro_plus]
 kind = "colab"
 account = "you@example.com"
+min_mib_per_s = 0.05
 
 [lab_a100]
 kind = "shell"
@@ -176,6 +177,8 @@ key = "~/.ssh/id_ed25519"
 persistent = true
 ```
 
+The connection pipeline defaults to `10 MiB/s` in each direction and `300 ms` RTT. Colab's measured sustained best is `8.8 MiB/s` up and `10.7 MiB/s` down, so it fails the default floor. The account example explicitly permits a slow link with `min_mib_per_s = 0.05`. Set `min_mib_per_s` and `max_rtt_ms` for your measurements. When all measured links fail the floor, the connection is refused even if an unprobed fallback connected.
+
 The project's `.letify/config.toml` gets only the alias, which is what makes the account usable in this project:
 
 ```toml

{letify-1.2.0 → letify-1.2.1}/docs/guide/07-troubleshooting.md

@@ -264,7 +264,7 @@ kind = "tunnel"
 mtu = 1280
 ```
 
-letify holds every connection strategy, Tailcat's hole punch included, to a floor: a probe below 5 MiB/s or above 300 ms round trip fails the connection instead of completing it, because a slow link is a failure, not a fallback. See [docs/SPEC.md, Link floor](../SPEC.md#link-floor). If the connection now fails with "below the floor", that is the diagnosis: the path is too slow to use, usually because Tailcat's own direct UDP punch did not succeed and it fell back to a relay. No relay path is offered as an alternative, so fix the underlying reachability instead: open the UDP port the punch needs, or set `address` to a direct SSH path if one exists on the same network. See [docs/NETWORK.md](../NETWORK.md).
+letify holds every connection strategy, Tailcat's hole punch included, to a floor: a probe below 10 MiB/s or above 300 ms round trip fails the connection instead of completing it, because a slow link is a failure, not a fallback. See [docs/SPEC.md, Link floor](../SPEC.md#link-floor). If the connection now fails with "below the floor", that is the diagnosis: the path is too slow to use, usually because Tailcat's own direct UDP punch did not succeed and it fell back to a relay. No relay path is offered as an alternative, so fix the underlying reachability instead: open the UDP port the punch needs, or set `address` to a direct SSH path if one exists on the same network. See [docs/NETWORK.md](../NETWORK.md).
 
 ### Gathered calls are not running in parallel
 

{letify-1.2.0 → letify-1.2.1}/docs/guide/ko/07-/353/254/270/354/240/234-/355/225/264/352/262/260.md

@@ -264,7 +264,7 @@ kind = "tunnel"
 mtu = 1280
 ```
 
-letify는 Tailcat 홀펀칭을 포함한 모든 연결 전략을 바닥값에 묶어 둡니다: 측정값이 5 MiB/s 미만이거나 왕복 300 ms를 넘으면 연결을 완료시키는 대신 실패시킵니다. 느린 링크는 폴백이 아니라 실패이기 때문입니다. [docs/SPEC.md의 Link floor](../../SPEC.md#link-floor)를 보세요. 이제 "below the floor"로 연결이 실패한다면 그것이 진단입니다: 경로가 너무 느려 쓸 수 없고, 보통 Tailcat의 직접 UDP 홀펀칭이 성공하지 못해 중계로 떨어졌기 때문입니다. 대안으로 중계 경로를 제공하지 않으므로, 도달성 자체를 고치세요: 홀펀칭에 필요한 UDP 포트를 열거나, 같은 망에 직접 SSH 경로가 있다면 `address`를 설정하세요. [docs/NETWORK.md](../../NETWORK.md)를 보세요.
+letify는 Tailcat 홀펀칭을 포함한 모든 연결 전략을 바닥값에 묶어 둡니다: 측정값이 10 MiB/s 미만이거나 왕복 300 ms를 넘으면 연결을 완료시키는 대신 실패시킵니다. 느린 링크는 폴백이 아니라 실패이기 때문입니다. [docs/SPEC.md의 Link floor](../../SPEC.md#link-floor)를 보세요. 이제 "below the floor"로 연결이 실패한다면 그것이 진단입니다: 경로가 너무 느려 쓸 수 없고, 보통 Tailcat의 직접 UDP 홀펀칭이 성공하지 못해 중계로 떨어졌기 때문입니다. 대안으로 중계 경로를 제공하지 않으므로, 도달성 자체를 고치세요: 홀펀칭에 필요한 UDP 포트를 열거나, 같은 망에 직접 SSH 경로가 있다면 `address`를 설정하세요. [docs/NETWORK.md](../../NETWORK.md)를 보세요.
 
 ### 모은 호출이 병렬로 돌지 않습니다
 

{letify-1.2.0 → letify-1.2.1}/docs/locales/README_ko.md

@@ -161,6 +161,7 @@ letify login shell lab_a100
 [colab_pro_plus]
 kind = "colab"
 account = "you@example.com"
+min_mib_per_s = 0.05
 
 [lab_a100]
 kind = "shell"
@@ -170,6 +171,8 @@ key = "~/.ssh/id_ed25519"
 persistent = true
 ```
 
+연결 파이프라인의 기본 기준은 양방향 `10 MiB/s`, RTT `300 ms`입니다. Colab의 측정된 지속 전송 최고값은 올리기 `8.8 MiB/s`, 내리기 `10.7 MiB/s`라서 기본 기준을 통과하지 못합니다. 위 계정의 `min_mib_per_s = 0.05`는 느린 연결을 명시적으로 허용하는 예시입니다. 실제 측정에 맞춰 `min_mib_per_s`와 `max_rtt_ms`를 설정하세요. 측정된 링크가 모두 기준 미달이면 측정하지 않은 fallback으로 바꾸지 않고 연결을 거부합니다.
+
 프로젝트의 `.letify/config.toml`에는 alias만 들어갑니다. 이 줄이 있어야 그 계정을 이 프로젝트에서 쓸 수 있습니다.
 
 ```toml

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

{letify-1.2.0 → letify-1.2.1}/letify/providers/colab.py

@@ -281,7 +281,27 @@ class Colab(Shell):
         from .colab_keepalive import account_lock
 
         with account_lock(account_directory(self.alias) / ".config" / "colab-cli"):
-            return self._cli("exec", "-s", session, stdin=source, timeout=timeout)
+            try:
+                return self._cli("exec", "-s", session, stdin=source, timeout=timeout)
+            except subprocess.TimeoutExpired as exc:
+                stderr = exc.stderr or ""
+                if isinstance(stderr, bytes):
+                    stderr = stderr.decode(errors="replace")
+                raise RuntimeFailure(
+                    f"{session}: colab exec timed out after {timeout} s; "
+                    "the notebook kernel may be busy or not answering",
+                    command=" ".join([*self._colab(), "exec", "-s", session]),
+                    stderr=stderr,
+                ) from exc
+            except RuntimeFailure as exc:
+                if "Timeout waiting for reply" not in exc.stderr:
+                    raise
+                raise RuntimeFailure(
+                    f"{session}: colab exec did not receive a reply; "
+                    "the notebook kernel may be busy or not answering",
+                    command=exc.command,
+                    stderr=exc.stderr,
+                ) from exc
 
     def sessions(self) -> list[str]:
         """Names of the sessions this account currently holds."""
@@ -507,5 +527,3 @@ __all__ = [
     "Colab",
     "ColabSessionReclaimed",
 ]
-
-

{letify-1.2.0 → letify-1.2.1}/letify/providers/kaggle.py

@@ -520,9 +520,9 @@ def cancel_run(cookie: str, run_id: int) -> None:
 
 
 def read_api_token(alias: str) -> str | None:
-    """Read the account's verbatim API token, or None when the file is unreadable or empty."""
+    """Read the account's API token with file whitespace stripped, or None if unavailable."""
     try:
-        token = (account_directory(alias) / "access_token").read_text(encoding="utf-8")
+        token = (account_directory(alias) / "access_token").read_text(encoding="utf-8").strip()
     except (OSError, UnicodeError):
         return None
     return token or None
@@ -544,6 +544,15 @@ def require_api_token(alias: str) -> str:
     return token
 
 
+def read_notebook_owner(alias: str) -> str | None:
+    """Read the public notebook owner saved by login, or None if unavailable."""
+    try:
+        owner = (account_directory(alias) / "username").read_text(encoding="utf-8").strip()
+    except (OSError, UnicodeError):
+        return None
+    return owner or None
+
+
 def delete_notebook_via_cli(alias: str, slug: str | None) -> bool:
     """Delete the ephemeral notebook through the official CLI, the only way it is deleted.
 
@@ -558,11 +567,8 @@ def delete_notebook_via_cli(alias: str, slug: str | None) -> bool:
     token = read_api_token(alias)
     if token is None:
         return False
-    try:
-        username = (account_directory(alias) / "username").read_text(encoding="utf-8").strip()
-    except (OSError, UnicodeError):
-        return False
-    if not username:
+    username = read_notebook_owner(alias)
+    if username is None:
         return False
     uv = tools.find_uv()
     if uv is None:
@@ -1036,6 +1042,11 @@ class Kaggle(Provider):
         The notebook is created fresh for this runtime alone, never reused from an earlier
         one: spec "Kaggle session token chain".
         """
+        if read_notebook_owner(self.alias) is None:
+            raise ConfigError(
+                f"{self.alias} has no Kaggle notebook owner. Log in again with: "
+                f"letify login kaggle {self.alias} --username <owner>"
+            )
         cookie = self._require_live_cookie()
         instance = getattr(runtime, "instance", None)
         gpu = getattr(instance, "gpu", None)

{letify-1.2.0 → letify-1.2.1}/letify/tools.py

@@ -265,9 +265,9 @@ def kaggle_cli_command(uv: str) -> list[str]:
 
 
 def kaggle_cli_environment(alias: str) -> dict[str, str]:
-    """Pass this account's verbatim token to the CLI through its child environment."""
+    """Pass this account's token without file whitespace through the child environment."""
     env = dict(os.environ)
-    token = (account_directory(alias) / "access_token").read_text(encoding="utf-8")
+    token = (account_directory(alias) / "access_token").read_text(encoding="utf-8").strip()
     env["KAGGLE_API_TOKEN"] = token
     return env
 

{letify-1.2.0 → letify-1.2.1}/letify/transport/pipeline.py

@@ -32,12 +32,11 @@ CACHE_RATIO = 0.5
 CACHE_TTL_SECONDS = 3600.0
 
 MIB = 1024 * 1024
-#: The default floor: a link under 5 MiB/s in either direction, or over 300 ms round trip,
+#: The default floor: a link under 10 MiB/s in either direction, or over 300 ms round trip,
 #: is a failure rather than a connection. See docs/INTENT.md, "A slow link is a failure,
-#: not a fallback", and docs/NETWORK.md, "Connection pipeline measurements", for the
-#: measured gap this is set against: a direct LAN or campus link runs 50 to 100 MiB/s at
-#: under 1 ms, a relayed Tailcat path has been measured at 1 to 2 MiB/s at 69 to 99 ms.
-DEFAULT_MIN_MIB_PER_S = 5.0
+#: not a fallback". Accounts can override the shared policy; providers cannot choose
+#: a lower default.
+DEFAULT_MIN_MIB_PER_S = 10.0
 DEFAULT_MAX_RTT_MS = 300.0
 
 
@@ -66,6 +65,8 @@ class LinkFloor:
             found.append(
                 f"round trip {result.rtt_ms:.1f} ms above the floor {self.max_rtt_ms:.0f} ms"
             )
+        if found:
+            found.append("account overrides: min_mib_per_s and max_rtt_ms")
         return found
 
 
@@ -270,7 +271,7 @@ class Pipeline:
 
         network = self.fingerprint() if self.cache is not None else None
         if self.cache is not None and network is not None:
-            kept = self._from_cache(applicable, network)
+            kept = self._from_cache(applicable, network, reasons)
             if kept is not None:
                 return kept
 
@@ -292,7 +293,7 @@ class Pipeline:
 
     # -- the cache -----------------------------------------------------------
 
-    def _from_cache(self, applicable: list[Any], network: Fingerprint) -> Any:
+    def _from_cache(self, applicable: list[Any], network: Fingerprint, reasons: list[str]) -> Any:
         entry = self.cache.load() if self.cache else None
         if entry is None:
             return None
@@ -336,6 +337,7 @@ class Pipeline:
         floored = self.floor.violations(measured)
         if floored:
             self._say(f"cached {name} rejected: below the floor: {', '.join(floored)}")
+            reasons.append(f"{name}: below the floor: {', '.join(floored)}")
             _close(link)
             return None
         short = _below(
@@ -459,12 +461,16 @@ class Pipeline:
         self, connected: list[Any], reasons: list[str], held: set[str]
     ) -> tuple[Any, ProbeResult | None]:
         """Pick among connected links. ``held`` names the strategies that cannot be probed."""
+        floored_out = [reason for reason in reasons if ": below the floor:" in reason]
         if len(connected) == 1:
             link = connected[0]
             try:
                 measured = self._measure(link)
             except Exception:
                 measured = None
+            if measured is None and floored_out:
+                _close(link)
+                raise ProviderUnavailable("shell", self._explain(reasons))
             if link.strategy in held:
                 self._fall_back(link)
             else:
@@ -491,7 +497,6 @@ class Pipeline:
             else:
                 probed.append((link, measured))
 
-        floored_out: list[str] = []
         above_floor: list[tuple[Any, ProbeResult]] = []
         for link, measured in probed:
             floored = self.floor.violations(measured)
@@ -525,14 +530,16 @@ class Pipeline:
                 self._say(f"chose {chosen.strategy}: only one connected and probed")
             else:
                 self._say(f"chose {chosen.strategy}: lowest rank within 25% of the fastest")
-        elif unprobed:
-            chosen, measured = unprobed[0], None
-            self._fall_back(chosen)
         elif floored_out:
+            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])
             )
+        elif unprobed:
+            chosen, measured = unprobed[0], None
+            self._fall_back(chosen)
         else:
             self._say("every probe failed")
             raise ProviderUnavailable("shell", self._explain([*reasons, "every probe failed"]))

{letify-1.2.0 → letify-1.2.1}/letify-core/Cargo.lock

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

{letify-1.2.0 → letify-1.2.1}/letify-core/Cargo.toml

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

{letify-1.2.0 → letify-1.2.1}/letify-ext/package-lock.json

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

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

{letify-1.2.0 → letify-1.2.1}/pyproject.toml

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

{letify-1.2.0 → letify-1.2.1}/tests/test_kaggle.py

@@ -127,6 +127,20 @@ def test_a_login_missing_only_the_key_is_refused(isolated_home, accept_cookie, c
     assert not (account("kaggle_a") / "cookie").exists()
 
 
+@pytest.mark.parametrize("owner", [None, "", "   "])
+def test_login_refuses_a_missing_owner_before_declaring_the_account(
+    isolated_home, accept_cookie, capsys, owner
+) -> None:
+    """Spec "Kaggle": a declared account must carry its notebook deletion owner."""
+    owner_args = [] if owner is None else ["--username", owner]
+    assert main(["login", "kaggle", "kaggle_a", "--cookie", make_cookie(),
+                 "--key", API_TOKEN, *owner_args, "--no-input"]) == 1
+    assert "notebook owner" in capsys.readouterr().err
+    assert not account("kaggle_a").exists()
+    assert not (Path.home() / ".letify" / "config.toml").exists()
+    assert accept_cookie == []
+
+
 def test_an_expired_cookie_is_refused_with_nothing_written(
     isolated_home, accept_cookie, capsys
 ) -> None:
@@ -268,6 +282,7 @@ def test_a_run_refuses_to_start_with_under_an_hour_left_on_the_cookie(isolated_h
     import letify
     from letify.config.secrets import write_secret
 
+    write_secret("kaggle_a", "username", "irack000")
     soon = datetime.now(UTC) + timedelta(minutes=30)
     write_secret("kaggle_a", "cookie", make_cookie(soon.strftime("%Y-%m-%dT%H:%M:%SZ")))
     runtime = type("R", (), {"name": "letify-t4-1"})()
@@ -786,6 +801,51 @@ def test_stopping_cancels_the_run_through_the_cookie_and_deletes_the_notebook_vi
     assert "kernels" in deletes[0]
 
 
+def test_stop_deletes_the_notebook_for_an_account_declared_through_login(
+    fake_kaggle, fake_kaggle_cli, capsys
+) -> None:
+    """Spec "Kaggle session token chain": login supplies the owner used by stop."""
+    for path in account("kaggle_a").iterdir():
+        path.unlink()
+    account("kaggle_a").rmdir()
+    assert main(["login", "kaggle", "kaggle_a", "--cookie", make_cookie(),
+                 "--username", "login_owner", "--key", API_TOKEN, "--no-input"]) == 0
+    assert home_config()["kaggle_a"] == {"kind": "kaggle"}
+    assert (account("kaggle_a") / "username").read_text() == "login_owner"
+    assert (account("kaggle_a") / "access_token").read_text() == API_TOKEN
+    assert (account("kaggle_a") / "cookie").read_text() == make_cookie()
+
+    provider, runtime, _channel = session_channel(fake_kaggle)
+    provider.stop(runtime)
+
+    assert fake_kaggle.kernels == set()
+    assert fake_kaggle.cancelled == [fake_kaggle.RUN_ID]
+    assert len(fake_kaggle_cli.calls) == 1
+    assert fake_kaggle_cli.calls[0][-4:] == [
+        "kernels", "delete", "-y", "login_owner/letify-runtime"
+    ]
+    assert fake_kaggle_cli.environments[0]["KAGGLE_API_TOKEN"] == API_TOKEN
+    assert "delete it by hand" not in capsys.readouterr().err
+
+
+@pytest.mark.parametrize("contents", [None, b"", b" \n", b"\xff"])
+def test_a_session_without_a_readable_owner_is_refused_before_creating_a_notebook(
+    fake_kaggle, contents
+) -> None:
+    """Spec "Kaggle": an incomplete account cannot create an undeletable notebook."""
+    from letify.errors import ConfigError
+
+    owner_path = account("kaggle_a") / "username"
+    if contents is None:
+        owner_path.unlink()
+    else:
+        owner_path.write_bytes(contents)
+    with pytest.raises(ConfigError, match=r"letify login kaggle kaggle_a.*--username"):
+        session_channel(fake_kaggle)
+    assert fake_kaggle.cloud_calls == []
+    assert fake_kaggle.kernels == set()
+
+
 def test_a_notebook_is_warned_about_by_name_when_the_cli_delete_fails(
     fake_kaggle, fake_kaggle_cli, capsys
 ) -> None:
@@ -949,3 +1009,25 @@ def test_a_september_access_token_file_authenticates_quota_without_login(
     assert fake_kaggle_cli.environments[0]["KAGGLE_API_TOKEN"] == API_TOKEN
     assert all(API_TOKEN not in argument and str(token_path) not in argument
                for argument in fake_kaggle_cli.calls[0])
+
+
+@pytest.mark.parametrize("contents", [API_TOKEN + "\n", "  " + API_TOKEN + "\r\n", " \n"])
+def test_reading_a_stored_api_token_strips_surrounding_whitespace(isolated_home, contents) -> None:
+    """Spec "Kaggle": stored token files may have trailing newlines."""
+    from letify.config.secrets import write_secret
+    from letify.providers.kaggle import read_api_token
+
+    write_secret("kaggle_a", "access_token", contents)
+    assert read_api_token("kaggle_a") == (contents.strip() or None)
+
+
+def test_a_stored_token_with_a_newline_authenticates_cli_deletion(
+    fake_kaggle_cli, kaggle_api_token
+) -> None:
+    """Spec "Kaggle": the CLI receives the token without file whitespace."""
+    from letify.providers.kaggle import delete_notebook_via_cli
+
+    kaggle_api_token.write_text(API_TOKEN + "\n", encoding="utf-8")
+    assert delete_notebook_via_cli("kaggle_a", "notebook63516d2758") is True
+    assert fake_kaggle_cli.calls[0][-1] == "irack000/notebook63516d2758"
+    assert fake_kaggle_cli.environments[0]["KAGGLE_API_TOKEN"] == API_TOKEN

{letify-1.2.0 → letify-1.2.1}/tests/test_providers.py

@@ -2640,6 +2640,7 @@ def test_colab_prepares_tailcat_before_the_connection_race(
 ) -> None:
     # Spec "Colab", Runtime tools: installation failure cannot silently lose the race.
     from letify import install
+
     patch_which(tools_module, present=True)
     found = FakeCompleted(stdout='LETIFY-TAILCAT "/remote/tailcat"\n')
     recorder = patch_run(colab_module, result=found)
@@ -2739,3 +2740,54 @@ def test_colab_diagnose_leaves_other_failures_unchanged_when_session_remains(
     diagnosed = provider.diagnose(runtime, failure)
     assert diagnosed is failure
 
+
+# Spec: Transport, Link floor and Colab.
+@pytest.mark.parametrize("provider_class", [Shell, Colab, Tunnel, Elice])
+def test_shell_accounts_share_the_floor_and_keep_account_overrides(provider_class):
+    from letify.transport.pipeline import MIB
+
+    default = provider_of(provider_class, "floor_default").link_floor
+    assert default.min_bps == 10 * MIB
+    assert default.max_rtt_ms == 300
+    custom = provider_of(provider_class, "floor_custom", min_mib_per_s=0.05, max_rtt_ms=500)
+    assert custom.link_floor.min_bps == 0.05 * MIB
+    assert custom.link_floor.max_rtt_ms == 500
+
+
+def test_colab_exec_reply_timeout_names_the_kernel_and_keeps_cli_evidence(
+    isolated_home, patch_which, patch_run
+):
+    patch_which(tools_module, present=True)
+    patch_run(
+        colab_module,
+        result=FakeCompleted(returncode=1, stderr="TimeoutError: Timeout waiting for reply"),
+    )
+    provider = provider_of(Colab, "colab_a", channel="exec")
+    runtime = type("R", (), {"name": "letify-a100-330e87"})()
+    channel = provider.open_channel(runtime)
+    with pytest.raises(letify.RuntimeFailure) as caught:
+        channel.eval("1", timeout=120)
+    assert "letify-a100-330e87" in str(caught.value)
+    assert "notebook kernel" in str(caught.value)
+    assert "busy or not answering" in str(caught.value)
+    assert "colab exec" in str(caught.value)
+    assert caught.value.stderr == "TimeoutError: Timeout waiting for reply"
+    assert "exec -s letify-a100-330e87" in caught.value.command
+
+
+def test_colab_exec_command_timeout_names_its_limit_and_kernel(
+    isolated_home, patch_which, patch_run
+):
+    import subprocess
+
+    patch_which(tools_module, present=True)
+    expired = subprocess.TimeoutExpired("colab exec", 120, stderr="kernel stalled")
+    patch_run(colab_module, error=expired)
+    provider = provider_of(Colab, "colab_a", channel="exec")
+    runtime = type("R", (), {"name": "letify-a100-330e87"})()
+    with pytest.raises(letify.RuntimeFailure) as caught:
+        provider.open_channel(runtime).eval("1", timeout=120)
+    assert "120 s" in str(caught.value)
+    assert "notebook kernel" in str(caught.value)
+    assert caught.value.stderr == "kernel stalled"
+    assert caught.value.__cause__ is expired

{letify-1.2.0 → letify-1.2.1}/tests/test_transport.py

@@ -520,9 +520,9 @@ def test_a_round_trip_above_the_floor_is_refused_even_with_fast_throughput(isola
         pipeline([broken, slow_round_trip], floor=floor).connect()
 
 
-def test_the_default_floor_is_five_mib_per_second_and_three_hundred_ms() -> None:
+def test_the_default_floor_is_ten_mib_per_second_and_three_hundred_ms() -> None:
     floor = LinkFloor.default()
-    assert floor.min_bps == 5.0 * MIB
+    assert floor.min_bps == 10.0 * MIB
     assert floor.max_rtt_ms == 300.0
 
 
@@ -589,3 +589,70 @@ def test_the_fingerprint_reads_the_public_address_from_stun(stun_server: StunSer
 
 def test_a_fingerprint_with_no_stun_answer_has_no_public_address() -> None:
     assert network_fingerprint(("127.0.0.1", 9), timeout=0.5).public_ip is None
+
+
+# Spec: Transport, Link floor.
+@pytest.mark.parametrize("up,down,rtt", [(2.6, 0.1, 177.4), (8.8, 10.7, 175.0)])
+def test_floor_rejection_cannot_select_an_unprobed_fallback(isolated_home, up, down, rtt):
+    slow = FakeStrategy("tailcat", 3, result=result(up, down, rtt))
+    fallback = FakeStrategy("fallback", 4, probed=False)
+    with pytest.raises(letify.ProviderUnavailable) as caught:
+        pipeline([slow, fallback], floor=LinkFloor.default()).connect()
+    message = str(caught.value)
+    assert "tailcat: below the floor" in message
+    assert f"up {up:.1f} MiB/s" in message
+    assert "10.0 MiB/s" in message
+    assert "min_mib_per_s" in message
+    assert "max_rtt_ms" in message
+    assert slow.links[0].closed
+    assert fallback.links[0].closed
+
+
+@pytest.mark.parametrize("race_fails", [False, True])
+def test_a_cached_floor_rejection_cannot_escape_to_an_unprobed_fallback(
+    isolated_home, monkeypatch, race_fails
+):
+    cache = LinkCache("lab")
+    cache.save("tailcat", result(20, 20), Fingerprint("203.0.113.7", "eth0"))
+    slow = FakeStrategy("tailcat", 3, result=result(2.6, 0.1, 177.4))
+    fallback = FakeStrategy("fallback", 4, probed=False)
+    attempt = slow.attempt
+
+    def reconnect(target, cancel=None):
+        if race_fails and slow.attempts:
+            raise OSError("connection lost after cached probe")
+        return attempt(target, cancel=cancel)
+
+    monkeypatch.setattr(slow, "attempt", reconnect)
+    with pytest.raises(letify.ProviderUnavailable, match="tailcat: below the floor"):
+        pipeline([slow, fallback], cache=cache, floor=LinkFloor.default()).connect()
+    assert all(link.closed for link in slow.links + fallback.links)
+    assert cache.load().probe == result(20, 20)
+
+
+def test_floor_rejections_name_both_account_overrides():
+    violations = LinkFloor.default().violations(result(2.6, 0.1, 500))
+    assert any("up 2.6 MiB/s" in text for text in violations)
+    assert any("down 0.1 MiB/s" in text for text in violations)
+    assert any("round trip 500.0 ms" in text for text in violations)
+    assert "min_mib_per_s" in ", ".join(violations)
+    assert "max_rtt_ms" in ", ".join(violations)
+
+
+# Spec: Transport, Link floor.
+def test_a_cached_floor_rejection_cannot_accept_a_lone_failed_probe(isolated_home, monkeypatch):
+    cache = LinkCache("lab")
+    cache.save("tailcat", result(20, 20), Fingerprint("203.0.113.7", "eth0"))
+    slow = FakeStrategy("tailcat", 3, result=result(2.6, 0.1, 177.4))
+    fallback = FakeStrategy("fallback", 4, probed=False, error="fallback unavailable")
+    attempt = slow.attempt
+
+    def reconnect(target, cancel=None):
+        if slow.attempts:
+            slow.probe_error = True
+        return attempt(target, cancel=cancel)
+
+    monkeypatch.setattr(slow, "attempt", reconnect)
+    with pytest.raises(letify.ProviderUnavailable, match="tailcat: below the floor"):
+        pipeline([slow, fallback], cache=cache, floor=LinkFloor.default()).connect()
+    assert all(link.closed for link in slow.links)