letify 1.2.0__tar.gz → 1.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 1.2.0
+Version: 1.2.2
 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.2}/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.2}/docs/guide/04-environments-and-data.md

@@ -43,7 +43,7 @@ Packages named in the lock file are installed in the runtime and referenced by n
 letify infers this from the lock file. Override the inference only when you need to:
 
 ```python
-env = env.ship("mypkg")     # send this module by value
+env = env.ship("mypkg")     # ship this module to the runtime
 ```
 
 This is why editing code and rerunning is cheap. Code is a few hundred kilobytes; the environment and the data are the expensive parts, and they are cached.

{letify-1.2.0 → letify-1.2.2}/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.2}/docs/guide/ko/04-/355/231/230/352/262/275/352/263/274-/353/215/260/354/235/264/355/204/260.md

@@ -43,7 +43,7 @@ lock 파일에 있는 패키지는 런타임에 설치되고 이름으로 참조
 letify가 lock 파일을 보고 판단합니다. 필요할 때만 덮어쓰세요.
 
 ```python
-env = env.ship("mypkg")     # 이 모듈을 내용으로 보냅니다
+env = env.ship("mypkg")     # 이 모듈을 런타임으로 전송합니다
 ```
 
 그래서 코드를 고치고 다시 돌리는 것이 쌉니다. 코드는 수백 KB이고, 비싼 것은 환경과 데이터이며 그건 캐시됩니다.

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

{letify-1.2.0 → letify-1.2.2}/letify/config/login.py

@@ -756,12 +756,25 @@ def colab_account(answers: Answers) -> dict[str, Any]:
 KAGGLE_COOKIE = "cookie"
 KAGGLE_COOKIE_PROMPT = "Kaggle cookie (from a logged-in kaggle.com tab): "
 
+#: What each credential prompt adds on a renewal, where a blank answer keeps the stored
+#: one. Spec "Kaggle account".
+KAGGLE_KEEP_SUFFIX = "[blank keeps the stored one] "
 
-def read_kaggle_cookie(answers: Answers, given: str | None) -> str:
-    """Return the cookie string, from the value given, a file it names, or a prompt."""
+
+def read_kaggle_cookie(answers: Answers, given: str | None, stored: str | None = None) -> str:
+    """Return the cookie string, from the value given, a file it names, or a prompt.
+
+    On a renewal the prompt says a blank answer keeps ``stored``, so the cookie, which is a
+    thirty day session, can be replaced without repasting the token. Spec "Kaggle account".
+    """
     text = (given or "").strip()
     if not text and answers.interactive:
-        text = read_password(KAGGLE_COOKIE_PROMPT).strip()
+        prompt = KAGGLE_COOKIE_PROMPT
+        if stored:
+            prompt = f"{KAGGLE_COOKIE_PROMPT}{KAGGLE_KEEP_SUFFIX}"
+        text = read_password(prompt).strip()
+    if not text and stored:
+        return stored
     if not text:
         raise LoginError(
             f"{answers.alias} needs the Kaggle cookie of a logged-in kaggle.com tab. "
@@ -794,9 +807,15 @@ def read_kaggle_token(
         username = read_line(KAGGLE_OWNER_PROMPT).strip()
     from ..providers.kaggle import read_api_token
 
-    key = given_key if given_key is not None else (read_api_token(answers.alias) or "")
-    if not key and answers.interactive:
-        key = read_password(KAGGLE_TOKEN_PROMPT)
+    stored = read_api_token(answers.alias)
+    key = given_key or ""
+    if not key.strip() and answers.interactive:
+        prompt = KAGGLE_TOKEN_PROMPT
+        if stored:
+            prompt = f"{KAGGLE_TOKEN_PROMPT}{KAGGLE_KEEP_SUFFIX}"
+        key = read_password(prompt)
+    if not key.strip() and stored:
+        key = stored
     if not username or not key:
         raise LoginError(
             f"{answers.alias} needs the Kaggle API token and notebook owner: pass "
@@ -827,7 +846,11 @@ def kaggle_account(answers: Answers) -> dict[str, Any]:
 
     username, key = read_kaggle_token(answers, answers.get("username"), answers.get("key"))
     given = answers.get(KAGGLE_COOKIE) or answers.token
-    cookie = read_kaggle_cookie(answers, given if isinstance(given, str) else None)
+    cookie = read_kaggle_cookie(
+        answers,
+        given if isinstance(given, str) else None,
+        stored=stored_secret(answers.alias, KAGGLE_COOKIE),
+    )
     try:
         kg.require_cookie_shape(cookie)
         expiry = kg.cookie_expiry(cookie)
@@ -954,6 +977,15 @@ def store_secret(alias: str, name: str, secret: str) -> None:
     secrets.write_secret(alias, name, secret)
 
 
+def stored_secret(alias: str, name: str) -> str | None:
+    """The credential already in the account directory, or None when there is none to keep."""
+    try:
+        value = (secrets.account_directory(alias) / name).read_text(encoding="utf-8").strip()
+    except (OSError, UnicodeError):
+        return None
+    return value or None
+
+
 def forget_secret(alias: str) -> bool:
     """Delete everything this machine holds for an account. Returns whether anything was there."""
     return secrets.forget_account(alias)

{letify-1.2.0 → letify-1.2.2}/letify/paths.py

@@ -37,7 +37,7 @@ ALLOWED_ACCOUNT_CREDENTIAL_FILES = frozenset(
         "eci.yaml",
         "cookie",
         "access_token",
-        "kaggle.json",
+        "username",
         "notebook_id",
         "known_hosts",
         "link.json",

{letify-1.2.0 → letify-1.2.2}/letify/protocol/driver.py

@@ -13,12 +13,14 @@ is no blob table, so every large argument travels again on every call.
 from __future__ import annotations
 
 import base64
+from collections.abc import Sequence
+from pathlib import Path
 from typing import Any
 
 from .codec import BEGIN, END, PROTOCOL_VERSION, dumps_call
 
 _TEMPLATE = """
-import base64, pickle, sys, traceback
+import base64, os, pickle, sys, traceback
 _PAYLOAD = "{payload}"
 _BEGIN, _END = "{begin}", "{end}"
 _VERSION = {version}
@@ -27,15 +29,22 @@ _NO_LETIFY = (
     "to letify (for example through letify.session_cache), cannot be loaded. Add it to "
     "the project with 'uv add letify' so uv.lock carries it into the runtime."
 )
-_SHIP_IS_NOT_INSTALL = (
-    "{{name!r}} is not importable in this runtime while the call's body was running. "
-    "Env.ship() sends a module by value: an object from it that the function captures "
-    "as a global is carried inside the call's payload, but the module itself is never "
-    "installed in the runtime, so 'import {{name}}' inside the function body has nothing "
-    "to find. Reference the name as a global the function closes over instead of "
-    "importing it inside the body, or install the package in the runtime's environment "
-    "(name it in uv.lock) so it can be imported there by reference."
-)
+_MODULES = {modules_code}
+_WORKSPACE = {workspace_root!r}
+if _MODULES:
+    _modules_dir = os.path.join(os.path.expanduser(_WORKSPACE), "modules")
+    os.makedirs(_modules_dir, exist_ok=True)
+    for _rel, _b64 in _MODULES.items():
+        _target = os.path.join(_modules_dir, _rel)
+        os.makedirs(os.path.dirname(_target), exist_ok=True)
+        with open(_target, "wb") as _f:
+            _f.write(base64.b64decode(_b64))
+    if _modules_dir not in sys.path:
+        sys.path.insert(0, _modules_dir)
+    _existing = os.environ.get("PYTHONPATH", "")
+    _parts = [p for p in _existing.split(os.pathsep) if p]
+    if _modules_dir not in _parts:
+        os.environ["PYTHONPATH"] = os.pathsep.join([_modules_dir, *_parts])
 
 def _emit(obj):
     try:
@@ -84,8 +93,6 @@ else:
     except BaseException as exc:
         if isinstance(exc, ModuleNotFoundError) and (exc.name or "").split(".")[0] == "letify":
             _error = _NO_LETIFY
-        elif isinstance(exc, ModuleNotFoundError):
-            _error = _SHIP_IS_NOT_INSTALL.format(name=exc.name)
         else:
             _error = "{{}}: {{}}".format(type(exc).__name__, exc)
         _emit({{
@@ -98,14 +105,36 @@ else:
 """
 
 
-def build(fn: Any, args: tuple, kwargs: dict) -> str:
+def build(
+    fn: Any,
+    args: tuple,
+    kwargs: dict,
+    *,
+    modules: Sequence[str] = (),
+    workspace_root: str = "~/.letify-runtime",
+) -> str:
     """Return the script that runs one call and prints its outcome."""
     payload = base64.b64encode(dumps_call(fn, args, kwargs)).decode()
+    modules_dict: dict[str, str] = {}
+    if modules:
+        from ..store.pathdata import collect_module
+
+        modules_root = f"{workspace_root.rstrip('/')}/modules"
+        for mod_name in modules:
+            placed = collect_module(mod_name, modules_root)
+            prefix = mod_name.replace(".", "/")
+            for rel, _digest, _size, local in placed.entries:
+                content = Path(local).read_bytes()
+                target_rel = f"{prefix}/{rel}" if placed.directory else prefix + Path(local).suffix
+                modules_dict[target_rel] = base64.b64encode(content).decode("ascii")
+
     return _TEMPLATE.format(
         payload=payload,
         begin=BEGIN,
         end=END,
         version=PROTOCOL_VERSION,
+        modules_code=repr(modules_dict),
+        workspace_root=workspace_root,
     )
 
 

{letify-1.2.0 → letify-1.2.2}/letify/protocol/worker.py

@@ -195,16 +195,6 @@ _NO_LETIFY = (
     "the project with 'uv add letify' so uv.lock carries it into the runtime."
 )
 
-_SHIP_IS_NOT_INSTALL = (
-    "{name!r} is not importable in this runtime while the call's body was running. "
-    "Env.ship() sends a module by value: an object from it that the function captures "
-    "as a global is carried inside the call's payload, but the module itself is never "
-    "installed in the runtime, so 'import {name}' inside the function body has nothing "
-    "to find. Reference the name as a global the function closes over instead of "
-    "importing it inside the body, or install the package in the runtime's environment "
-    "(name it in uv.lock) so it can be imported there by reference."
-)
-
 
 def _ship_main_to_children(cloudpickle):
     """Let a child process the body spawns rebuild what the caller's __main__ defined.
@@ -266,6 +256,15 @@ def _reply(stream, outcome):
 
 def _op_call(request):
     data = request.pop("data", None)
+    modules_dir = request.pop("modules_dir", None)
+    if modules_dir:
+        modules_dir = os.path.expanduser(modules_dir)
+        if modules_dir not in sys.path:
+            sys.path.insert(0, modules_dir)
+        existing = os.environ.get("PYTHONPATH", "")
+        parts = [p for p in existing.split(os.pathsep) if p]
+        if modules_dir not in parts:
+            os.environ["PYTHONPATH"] = os.pathsep.join([modules_dir, *parts])
     if data is None:
         return _call(request)
     state = _data_register(data)
@@ -872,10 +871,18 @@ def _data_place_now(state, path, entry):
     # turns it into a private copy. Spec "Materializing and the rewritten path".
     linked = False
     try:
-        os.link(source, path)
-        linked = True
+        if os.path.exists(path) and os.stat(path).st_ino == os.stat(source).st_ino:
+            linked = True
     except OSError:
         pass
+    if not linked:
+        try:
+            if os.path.exists(path):
+                os.remove(path)
+            os.link(source, path)
+            linked = True
+        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".
@@ -1533,15 +1540,7 @@ def _call(request):
         # refers to it when loaded, so the same explanation applies.
         if (exc.name or "").split(".")[0] == "letify":
             raise ModuleNotFoundError(_NO_LETIFY, name=exc.name) from exc
-        # A package Env.ship() sends by value never lands on this runtime's
-        # sys.path: cloudpickle only puts a captured global in the payload, it
-        # does not install anything. An import statement inside the body still
-        # runs against this interpreter's own path and fails here, even though
-        # the same name reached the call fine as a global. Say so, because the
-        # bare ModuleNotFoundError reads as a missing dependency rather than as
-        # this shape of call.
-        explained = _SHIP_IS_NOT_INSTALL.format(name=exc.name)
-        raise ModuleNotFoundError(explained, name=exc.name) from exc
+        raise
     return {"ok": True, "value": value}
 
 

{letify-1.2.0 → letify-1.2.2}/letify/providers/base.py

@@ -99,8 +99,8 @@ class Provider(abc.ABC):
         """What this account has, read from the entry's device table.
 
         This is the only thing that bounds how much runs at once. An entry that declares
-        nothing falls back to whatever the provider discovers, one of each, because a
-        provider that can be asked should not have to be told.
+        nothing falls back to the device counts of the shapes the provider discovers,
+        because a provider that can be asked should not have to be told.
         """
         if self._inventory is None:
             declared = read_table(self.config.options)
@@ -108,7 +108,7 @@ class Provider(abc.ABC):
                 # Keyed by what an instance calls itself, so a discovered shape and its
                 # inventory entry are the same name. A CPU shape reports "cpu".
                 declared = {
-                    instance.accelerator: Devices(instance.accelerator)
+                    instance.accelerator: Devices(instance.accelerator, count=instance.devices)
                     for instance in self.discover().values()
                 }
             self._inventory = declared

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

@@ -278,10 +278,27 @@ class Colab(Shell):
         return env
 
     def _exec(self, session: str, source: str, timeout: float | None) -> str:
-        from .colab_keepalive import account_lock
-
-        with account_lock(account_directory(self.alias) / ".config" / "colab-cli"):
+        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."""
@@ -309,8 +326,27 @@ class Colab(Shell):
         from ..transport.rendezvous import ColabRendezvous
 
         name = runtime.name
+
+        def prepare_tailcat() -> str | None:
+            from .. import install
+
+            if not (
+                install.find("tailcat", link_cache=False) or self.config.option("tailcat_binary")
+            ):
+                return None
+            output = self._exec(name, install.remote_tailcat_source(), 180)
+            for line in output.splitlines():
+                if line.startswith("LETIFY-TAILCAT "):
+                    return json.loads(line[len("LETIFY-TAILCAT ") :])
+            raise RuntimeFailure(
+                "tailcat installation gave no verified binary path",
+                stderr=output.strip(),
+            )
+
         return ColabRendezvous(
-            lambda source, timeout: self._exec(name, source, timeout), self._public_key()
+            lambda source, timeout: self._exec(name, source, timeout),
+            self._public_key(),
+            prepare_tailcat=prepare_tailcat,
         )
 
     def fallback(self, runtime: Runtime | None = None) -> Callable[[], Link] | None:
@@ -330,20 +366,6 @@ class Colab(Shell):
     def target(self, runtime: Runtime | None = None) -> Target:
         target = super().target(runtime)
         target.user = self.user or "root"
-        if runtime is not None and target.rendezvous.unavailable() is None:
-            from .. import install
-
-            if install.find("tailcat", link_cache=False) or self.config.option("tailcat_binary"):
-                output = self._exec(runtime.name, install.remote_tailcat_source(), 180)
-                for line in output.splitlines():
-                    if line.startswith("LETIFY-TAILCAT "):
-                        target.rendezvous.binary = json.loads(line[len("LETIFY-TAILCAT ") :])
-                        break
-                else:
-                    raise RuntimeFailure(
-                        "tailcat installation gave no verified binary path",
-                        stderr=output.strip(),
-                    )
         if runtime is not None:
             # Each runtime is a new VM with a new host key.
             target.host_key_alias = f"letify-{self.alias}-{runtime.name}"
@@ -507,5 +529,3 @@ __all__ = [
     "Colab",
     "ColabSessionReclaimed",
 ]
-
-

{letify-1.2.0 → letify-1.2.2}/letify/providers/colab_keepalive.py

@@ -28,8 +28,8 @@ READY = "LETIFY-KEEP-ALIVE ready"
 
 
 @contextlib.contextmanager
-def account_lock(directory: Path) -> Iterator[None]:
-    """Serialize full kernel commands sharing one account's CLI state."""
+def account_lock(directory: Path, *, blocking: bool = True) -> Iterator[bool]:
+    """Serialize wakes sharing account CLI state, optionally without waiting."""
     directory.mkdir(parents=True, exist_ok=True)
     with (directory / "letify-wake.lock").open("a+b") as handle:
         if os.name == "nt":  # pragma: no cover - Windows file locking
@@ -38,13 +38,23 @@ def account_lock(directory: Path) -> Iterator[None]:
             handle.write(b"\0")
             handle.flush()
             handle.seek(0)
-            msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK, 1)
+            try:
+                msvcrt.locking(handle.fileno(), msvcrt.LK_LOCK if blocking else msvcrt.LK_NBLCK, 1)
+            except OSError:
+                if blocking:
+                    raise
+                yield False
+                return
         else:
             import fcntl
 
-            fcntl.flock(handle.fileno(), fcntl.LOCK_EX)
+            try:
+                fcntl.flock(handle.fileno(), fcntl.LOCK_EX | (0 if blocking else fcntl.LOCK_NB))
+            except BlockingIOError:
+                yield False
+                return
         try:
-            yield
+            yield True
         finally:
             if os.name == "nt":  # pragma: no cover - Windows file locking
                 handle.seek(0)
@@ -60,7 +70,15 @@ def wake(config: dict[str, Any]) -> float:
     result = None
     exc = None
     try:
-        with account_lock(Path(config["directory"])):
+        with account_lock(Path(config["directory"]), blocking=False) as acquired:
+            if not acquired:
+                entry = record(config, "wake_skipped", reason="account_busy")
+                print(
+                    f"{entry['timestamp']} letify: wake {config['session']} skipped: account busy",
+                    file=sys.stderr,
+                    flush=True,
+                )
+                return SUCCESS_INTERVAL
             result = subprocess.run(
                 command, input="pass\n", capture_output=True, text=True, timeout=WAKE_TIMEOUT
             )

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

@@ -65,12 +65,12 @@ if TYPE_CHECKING:
     from ..runtime.channel import Channel
     from ..runtime.session import Runtime
 
-#: Accelerators a Kaggle session can be started with, the memory of one card, and the name
-#: the internal API knows the card by. Both are ones the web app offers, so a session can be
-#: started on either. CPU is the empty compute, so it carries no accelerator name.
+#: GPU session shapes, with memory per card, device count and the internal API name.
+#: P100 remains available through the API although the web UI no longer lists it.
+#: CPU is the empty compute, so it carries no accelerator name.
 GPUS = {
-    "P100": {"vram_gb": 16, "accelerator": "NVIDIA_TESLA_P100"},
-    "T4": {"vram_gb": 16, "accelerator": "NVIDIA_TESLA_T4"},
+    "P100": {"vram_gb": 16, "devices": 1, "accelerator": "NVIDIA_TESLA_P100"},
+    "T4": {"vram_gb": 16, "devices": 2, "accelerator": "NVIDIA_TESLA_T4"},
 }
 TPUS = ("TPU_V3_8",)
 
@@ -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:
@@ -968,7 +974,10 @@ class Kaggle(Provider):
         """The fixed list of accelerators a Kaggle session offers. No call is made."""
         table: dict[str, Instance] = {"CPU": Instance(self, gpu=None)}
         table.update(
-            {name: Instance(self, gpu=name, vram_gb=spec["vram_gb"]) for name, spec in GPUS.items()}
+            {
+                name: Instance(self, gpu=name, vram_gb=spec["vram_gb"], devices=spec["devices"])
+                for name, spec in GPUS.items()
+            }
         )
         table.update({name: Instance(self, tpu=name) for name in TPUS})
         return table
@@ -1036,10 +1045,15 @@ 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)
-        accelerator = GPUS[gpu]["accelerator"] if gpu in GPUS else None
+        accelerator = GPUS[gpu]["accelerator"] if gpu in GPUS else getattr(instance, "tpu", None)
         run, url, notebook, slug = live_session_url(self.alias, cookie, accelerator)
         session = Session(self.alias, url)
         session.wait_alive()

{letify-1.2.0 → letify-1.2.2}/letify/runtime/channel.py

@@ -29,7 +29,7 @@ import subprocess
 import sys
 import threading
 import time
-from collections.abc import Callable, Iterator
+from collections.abc import Callable, Iterator, Sequence
 from typing import IO, Any
 
 from .. import protocol
@@ -112,6 +112,7 @@ class Channel(abc.ABC):
         kwargs: dict,
         *,
         timeout: float | None = None,
+        modules: Sequence[str] = (),
     ) -> tuple[Any, str]:
         """Run one function call inside the runtime."""
         head, buffers = protocol.dumps_call_parts(fn, args, kwargs)
@@ -908,10 +909,11 @@ class OneShotChannel(Channel):
         kwargs: dict,
         *,
         timeout: float | None = None,
+        modules: Sequence[str] = (),
     ) -> tuple[Any, str]:
         from ..protocol import driver
 
-        source = driver.build(fn, args, kwargs)
+        source = driver.build(fn, args, kwargs, modules=modules)
         stdout = self._run(source, timeout)
         logs, value = protocol.parse(stdout, runtime_key=self.name)
         return value, logs