letify 2.2.0__tar.gz → 2.4.0__tar.gz

{letify-2.2.0 → letify-2.4.0}/PKG-INFO

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

{letify-2.2.0 → letify-2.4.0}/letify/launcher.py

@@ -486,7 +486,7 @@ class Launcher:
         for alias in self.config.order:
             try:
                 provider = self.provider(alias)
-                supported = provider.kind == "colab"
+                supported = provider.discovers_sessions
                 rows.append(
                     {
                         "alias": alias,

{letify-2.2.0 → letify-2.4.0}/letify/providers/base.py

@@ -354,10 +354,59 @@ class Provider(abc.ABC):
             return table[name]
         if name.upper() in table:
             return table[name.upper()]
+        retired = self.retired_reason(name)
+        if retired:
+            raise UnknownInstance(f"{self.alias} does not offer {name!r}. {retired}")
         raise UnknownInstance(
             f"{self.alias} does not offer {name!r}. Available: {', '.join(sorted(table))}"
         )
 
+    #: Whether this provider can be asked what sessions the account already holds. A
+    #: launcher reads it rather than naming provider kinds. Spec "Kaggle", finding the
+    #: notebooks letify owns.
+    discovers_sessions: bool = False
+
+    def sessions(self) -> list[str]:
+        """What the account already holds, for a provider that can be asked.
+
+        Empty for one that cannot, and empty rather than raising when the answer cannot be
+        read: a command asking what exists should not fail because nothing answered.
+        """
+        return []
+
+    def expected_cards(self, instance: Any) -> tuple[str, int] | None:
+        """The card name fragment and count a session for ``instance`` must have, or None.
+
+        None means the provider gives what it is asked for, so there is nothing to check.
+        A provider whose service may answer with another card overrides it. Spec "Kaggle",
+        the accelerators.
+        """
+        return None
+
+    @property
+    def fallback_mib_per_s(self) -> float:
+        """What this provider's own fallback carries, or 0 when it is not known.
+
+        Spec "A floor rejection never picks something slower": a link the floor rejected
+        is kept when it beats this, because refusing a slow link only makes sense when
+        what happens instead is better.
+        """
+        value = self.config.option("fallback_mib_per_s")
+        return max(0.0, float(value)) if isinstance(value, (int, float)) else 0.0
+
+    @property
+    def any_accelerator(self) -> bool:
+        """Whether a card other than the one asked for is accepted, from ``any_accelerator``."""
+        return self.config.option("any_accelerator") is True
+
+    def retired_reason(self, name: str) -> str | None:
+        """Why an accelerator this provider once offered is gone, or None.
+
+        A name the provider's service answers with a different card belongs here rather
+        than in the inventory, because a declaration states where a function runs.
+        """
+        return None
+
     def device(self, name: str) -> Instance:
         """Look up an accelerator by name."""
         return getattr(self, name)

{letify-2.2.0 → letify-2.4.0}/letify/providers/colab.py

@@ -300,6 +300,8 @@ class Colab(Shell):
                 stderr=exc.stderr,
             ) from exc
 
+    discovers_sessions = True
+
     def sessions(self) -> list[str]:
         """Names of the sessions this account currently holds."""
         names = []

{letify-2.2.0 → letify-2.4.0}/letify/providers/kaggle.py

@@ -32,6 +32,7 @@ import urllib.parse
 import urllib.request
 from collections.abc import Mapping
 from datetime import UTC, datetime
+from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
 from .. import tools
@@ -67,13 +68,20 @@ if TYPE_CHECKING:
     from ..runtime.session import Runtime
 
 #: 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, "devices": 1, "accelerator": "NVIDIA_TESLA_P100"},
-    "T4": {"vram_gb": 16, "devices": 2, "accelerator": "NVIDIA_TESLA_T4"},
+    "T4": {"vram_gb": 16, "devices": 2, "accelerator": "NVIDIA_TESLA_T4", "model": "T4"},
 }
 TPUS = ("TPU_V3_8",)
+#: Cards Kaggle no longer serves, and what it does instead. Offering one would let a
+#: declaration say P100 and run on something else: spec "Kaggle", the accelerators.
+RETIRED = {
+    "P100": (
+        "Kaggle retired the Tesla P100 on 2026-09-15 and switches a notebook that asks "
+        "for it to two T4s, so the card and the card count would both differ from the "
+        "declaration. Use T4, which is two cards of 16 GB"
+    ),
+}
 
 #: The internal Kaggle service surface the web app uses, authenticated by the session cookie.
 KAGGLE_INTERNAL = "https://www.kaggle.com/api/i/"
@@ -95,6 +103,9 @@ FIRESTORE_DOCUMENT = (
 #: runnable. A freshly created empty notebook cancels its own session because it has nothing
 #: to run, so the session is started with one committed cell.
 NOTEBOOK_TITLE = "letify runtime"
+#: What the kernel bridge carries, measured sending 64 MiB on a live account. The
+#: floor compares a link against this rather than refusing one that beats it.
+BRIDGE_MIB_PER_S = 2.0
 NOTEBOOK_BODY = json.dumps(
     {
         "cells": [
@@ -504,6 +515,9 @@ def live_session_url(
     403 on it is the account's own answer, not a stale notebook's.
     """
     kernel, slug = new_notebook(alias, cookie)
+    # Spec "Kaggle", finding the notebooks letify owns: recorded before anything can fail,
+    # so a run that dies next still leaves a trail to its notebook.
+    record_notebook(alias, slug)
     run = start_run(cookie, kernel, accelerator)
     id_token = firebase_id_token(cookie)
     webtier = webtier_session(cookie, id_token, run)
@@ -554,6 +568,116 @@ def read_notebook_owner(alias: str) -> str | None:
     return owner or None
 
 
+def notebook_record(alias: str) -> Path:
+    """Where the refs of the notebooks letify created on this account are kept."""
+    return account_directory(alias) / "notebooks"
+
+
+def recorded_notebooks(alias: str) -> list[str]:
+    """The refs letify believes it created, in the order it created them."""
+    try:
+        text = notebook_record(alias).read_text(encoding="utf-8")
+    except OSError:
+        return []
+    seen: list[str] = []
+    for line in text.splitlines():
+        ref = line.strip()
+        if ref and ref not in seen:
+            seen.append(ref)
+    return seen
+
+
+def record_notebook(alias: str, slug: str | None) -> None:
+    """Note that letify created this notebook, so a later process can still find it.
+
+    Spec "Kaggle", finding the notebooks letify owns: Kaggle names the notebook itself, so
+    the record is the only thing that tells letify's from the user's own. Never raises; a
+    notebook letify cannot record is one it may fail to clean up, not a failed run.
+    """
+    username = read_notebook_owner(alias)
+    if not slug or username is None:
+        return
+    try:
+        path = notebook_record(alias)
+        path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+        with path.open("a", encoding="utf-8") as handle:
+            handle.write(f"{username}/{slug}\n")
+    except OSError:
+        pass
+
+
+def forget_notebook(alias: str, slug: str | None) -> None:
+    """Drop a notebook from the record, once it is gone from the account."""
+    username = read_notebook_owner(alias)
+    if not slug or username is None:
+        return
+    ref = f"{username}/{slug}"
+    kept = [line for line in recorded_notebooks(alias) if line != ref]
+    try:
+        notebook_record(alias).write_text(
+            "".join(f"{line}\n" for line in kept), encoding="utf-8"
+        )
+    except OSError:
+        pass
+
+
+def notebooks_on_account(alias: str) -> list[str] | None:
+    """The refs the account has, through the official CLI, or None when it cannot be asked.
+
+    None and an empty list mean different things: nothing answered, against the account
+    having no notebooks. Never raises.
+    """
+    if read_api_token(alias) is None:
+        return None
+    uv = tools.find_uv()
+    if uv is None:
+        return None
+    import csv
+    import io
+    import subprocess
+
+    try:
+        result = subprocess.run(
+            [*tools.kaggle_cli_command(uv), "kernels", "list", "--mine", "--csv"],
+            env=tools.kaggle_cli_environment(alias),
+            capture_output=True,
+            text=True,
+            timeout=REST_TIMEOUT,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    try:
+        rows = list(csv.DictReader(io.StringIO(result.stdout or "")))
+    except csv.Error:
+        return None
+    return [(row.get("ref") or "").strip() for row in rows if (row.get("ref") or "").strip()]
+
+
+def list_notebooks_via_cli(alias: str) -> list[str]:
+    """The recorded notebooks this account still has. Spec "Kaggle", finding them.
+
+    A ref the record names and the account no longer has was deleted elsewhere, so it is
+    dropped from the record rather than reported.
+    """
+    recorded = recorded_notebooks(alias)
+    if not recorded:
+        return []
+    present = notebooks_on_account(alias)
+    if present is None:
+        return []
+    live = [ref for ref in recorded if ref in set(present)]
+    if live != recorded:
+        try:
+            notebook_record(alias).write_text(
+                "".join(f"{ref}\n" for ref in live), encoding="utf-8"
+            )
+        except OSError:
+            pass
+    return live
+
+
 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.
 
@@ -596,6 +720,7 @@ def delete_notebook_best_effort(alias: str, kernel_id: int, slug: str | None) ->
     slug or id, never by its cookie, so the user can delete it by hand on kaggle.com.
     """
     if delete_notebook_via_cli(alias, slug):
+        forget_notebook(alias, slug)
         return
     import sys
 
@@ -990,7 +1115,9 @@ class Kaggle(Provider):
     usage_unit = "GPU hours"
     usage_source = "the weekly accelerator quota the official Kaggle CLI's quota command reads"
 
-    default_workspace = "/kaggle/working/letify"
+    # Spec "Kaggle runtimes": /kaggle/working is the notebook's output directory on its
+    # own 19.5 GB device, while /kaggle is the overlay with about 1 TB free.
+    default_workspace = "/kaggle/letify"
 
     def account_note(self) -> str | None:
         """How the account's cookie is doing, for `letify providers`, with no network call.
@@ -1025,6 +1152,24 @@ class Kaggle(Provider):
         table.update({name: Instance(self, tpu=name) for name in TPUS})
         return table
 
+    discovers_sessions = True
+
+    def sessions(self) -> list[str]:
+        """The notebooks letify owns on this account, which is where an orphan shows up."""
+        return list_notebooks_via_cli(self.alias)
+
+    def expected_cards(self, instance: Any) -> tuple[str, int] | None:
+        """What a Kaggle session must have, because Kaggle may answer with another card."""
+        gpu = getattr(instance, "gpu", None)
+        spec = GPUS.get(gpu) if gpu else None
+        if spec is None:
+            return None
+        return str(spec["model"]), int(spec["devices"])
+
+    def retired_reason(self, name: str) -> str | None:
+        """Why Kaggle no longer serves a card it once did. Spec "Kaggle", the accelerators."""
+        return RETIRED.get(name.upper())
+
     def store_backend(self) -> str:
         return "filesystem"
 
@@ -1179,6 +1324,7 @@ class Kaggle(Provider):
         return LinkFloor(
             min_bps=float(min_mib) * MIB if isinstance(min_mib, (int, float)) else default.min_bps,
             max_rtt_ms=float(max_rtt) if isinstance(max_rtt, (int, float)) else default.max_rtt_ms,
+            fallback_bps=self.fallback_mib_per_s * MIB,
         )
 
     @property
@@ -1199,7 +1345,15 @@ class Kaggle(Provider):
 
         try:
             link = self.link_over(bridge, name=name)
-        except Exception:
+        except Exception as exc:
+            # Never silent: a session that quietly changed channel is one nobody can
+            # account for. Spec "A floor rejection never picks something slower".
+            from ..transport.announce import printer
+
+            printer(bool(self.__dict__.get("announce", True)))(
+                f"{self.alias}: the kernel bridge is carrying {name} at about "
+                f"{self.fallback_mib_per_s:.1f} MiB/s, because no link was chosen: {exc}"
+            )
             return bridge
         self._links[name] = link
         return PersistentChannel(
@@ -1207,6 +1361,17 @@ class Kaggle(Provider):
             name=name,
         )
 
+    @property
+    def fallback_mib_per_s(self) -> float:
+        """The kernel bridge, measured at 2.0 MiB/s sending 64 MiB on a live account.
+
+        Spec "A floor rejection never picks something slower": without this a punched link
+        at down 8.1 MiB/s was refused for being under the 10 MiB/s floor and 26 GB went
+        over the 2 MiB/s bridge instead.
+        """
+        value = self.config.option("fallback_mib_per_s")
+        return max(0.0, float(value)) if isinstance(value, (int, float)) else BRIDGE_MIB_PER_S
+
     @property
     def transfer_connection_cost_s(self) -> float:
         """A punch, which is what one more stream costs here. Measured at about 10 s."""

{letify-2.2.0 → letify-2.4.0}/letify/runtime/bootstrap.py

@@ -130,6 +130,24 @@ def project_dir(workspace_root: str, env: Env) -> str:
     return f"{workspace_root.rstrip('/')}/project/{env.key}"
 
 
+#: Reads the cards a runtime has, without nvidia-smi, which a Kaggle image lacks on PATH.
+#: Spec "Kaggle", the accelerators.
+CARD_SOURCE = (
+    "import glob\n"
+    "__letify_cards = []\n"
+    "for _letify_path in sorted(glob.glob('/proc/driver/nvidia/gpus/*/information')):\n"
+    "    try:\n"
+    "        with open(_letify_path) as _letify_handle:\n"
+    "            for _letify_line in _letify_handle:\n"
+    "                if _letify_line.startswith('Model:'):\n"
+    "                    __letify_cards.append(_letify_line.split(':', 1)[1].strip())\n"
+    "                    break\n"
+    "    except OSError:\n"
+    "        pass\n"
+    "__letify_value__ = __letify_cards\n"
+)
+
+
 def packages_in(files: dict[str, bytes]) -> int:
     """How many packages the lock names, for the line the environment build prints.
 
@@ -158,6 +176,15 @@ def project_files(env: Env) -> dict[str, bytes]:
                 f"pyproject.toml and uv.lock, and {directory.resolve()} has no {name}. "
                 f"Run 'uv lock' in the project first"
             )
+    lock = files.get("uv.lock") or b""
+    if b'name = "letify"' not in lock and b'name = "cloudpickle"' not in lock:
+        raise ConfigError(
+            f"the worker unpickles a declared body with cloudpickle, and a body that uses "
+            f"letify's own names imports letify on the runtime, so "
+            f"{(directory / 'uv.lock').resolve()} has to name letify or at least cloudpickle. "
+            f"It names neither, and the session would fail there with ModuleNotFoundError. "
+            f"Add letify to the project and run 'uv lock' again"
+        )
     local = local_python()
     pinned = files.get(".python-version")
     if pinned is not None:

{letify-2.2.0 → letify-2.4.0}/letify/runtime/session.py

@@ -130,6 +130,7 @@ class Runtime:
             self.worker_pid = int(self.stat()["pid"])
             self.provider.add_worker_pid(self.worker_pid)
         self.restrict_devices()
+        self.check_devices()
         if self.provider.needs_lease:
             self.lease = Lease(self)
             self.lease.arm()
@@ -691,6 +692,43 @@ class Runtime:
         self.python = where["python"]
         self.channel.switch_interpreter(where["python"])
 
+    def check_devices(self) -> None:
+        """Refuse a session whose cards are not the ones the instance asked for.
+
+        Spec "Kaggle", the accelerators: a provider may answer a request with a different
+        card. Run before the environment is built, so a wrong card costs seconds rather
+        than the minutes a sync takes.
+        """
+        from ..errors import InsufficientDevices
+        from . import bootstrap
+
+        instance = getattr(self, "instance", None)
+        expected = self.provider.expected_cards(instance)
+        if expected is None:
+            return
+        fragment, count = expected
+        try:
+            cards = self.eval(bootstrap.CARD_SOURCE, timeout=120)
+        except Exception:
+            # Reading /proc is not worth failing a session over when it cannot be read.
+            return
+        cards = [str(card) for card in cards or ()]
+        matched = [card for card in cards if fragment.casefold() in card.casefold()]
+        if len(matched) == count and len(cards) == count:
+            return
+        asked = getattr(instance, "accelerator", None) or fragment
+        arrived = ", ".join(cards) if cards else "no GPU at all"
+        message = (
+            f"{self.name}: {self.provider.alias} was asked for {count} x {asked} and the "
+            f"session has {arrived}. A declaration says where a function runs, so the "
+            f"session is not used. Set any_accelerator = true on the account to accept "
+            f"whatever card it is given"
+        )
+        if self.provider.any_accelerator:
+            self._say(f"card mismatch accepted: asked {count} x {asked}, got {arrived}")
+            return
+        raise InsufficientDevices(message)
+
     def check_interpreter(self) -> None:
         """Refuse a worker whose Python major.minor differs from this process."""
         from . import bootstrap

{letify-2.2.0 → letify-2.4.0}/letify/transport/pipeline.py

@@ -61,11 +61,39 @@ class LinkFloor:
 
     min_bps: float
     max_rtt_ms: float
+    #: What the provider's own fallback carries, when it is known. A link the floor
+    #: rejected is kept when it beats this. Spec "A floor rejection never picks something
+    #: slower".
+    fallback_bps: float = 0.0
 
     @classmethod
     def default(cls) -> LinkFloor:
         return cls(min_bps=DEFAULT_MIN_MIB_PER_S * MIB, max_rtt_ms=DEFAULT_MAX_RTT_MS)
 
+    def kept_below(self, result: ProbeResult, floored: list[str]) -> str | None:
+        """Why a link the floor rejected is used anyway, or None when it is not.
+
+        Spec "A floor rejection never picks something slower".
+        """
+        if not floored or not self.beats_fallback(result):
+            return None
+        return (
+            f"kept below the floor, because the fallback carries "
+            f"{self.fallback_bps / MIB:.1f} MiB/s"
+        )
+
+    def beats_fallback(self, result: ProbeResult) -> bool:
+        """Whether this probe is faster than the path that would be used instead.
+
+        Spec "A floor rejection never picks something slower": the floor refuses a slow
+        link so a slow link is not used, which is only right when what happens instead is
+        better. A provider with no measurable fallback has nothing to compare against, so
+        the answer is False and the rejection stands.
+        """
+        if not self.fallback_bps:
+            return False
+        return result.upload_bps > self.fallback_bps and result.download_bps > self.fallback_bps
+
     def violations(self, result: ProbeResult) -> list[str]:
         """Each direction, or the round trip, that the probe failed to clear."""
         found = _below(
@@ -312,6 +340,10 @@ class Pipeline:
                 return link
             if measured is not None:
                 floored = self.floor.violations(measured)
+                kept = self.floor.kept_below(measured, floored)
+                if kept:
+                    self._say(f"{link.strategy} {kept}")
+                    floored = []
                 if floored:
                     self._say(f"rejected {link.strategy}: below the floor: {', '.join(floored)}")
                     _close(link)
@@ -389,6 +421,10 @@ class Pipeline:
             _close(link)
             return None
         floored = self.floor.violations(measured)
+        kept = self.floor.kept_below(measured, floored)
+        if kept:
+            self._say(f"cached {name} {kept}")
+            floored = []
         if floored:
             self._say(f"cached {name} rejected: below the floor: {', '.join(floored)}")
             reasons.append(f"{name}: below the floor: {', '.join(floored)}")
@@ -573,6 +609,10 @@ class Pipeline:
             else:
                 if measured is not None:
                     floored = self.floor.violations(measured)
+                    kept = self.floor.kept_below(measured, floored)
+                    if kept:
+                        self._say(f"{link.strategy} {kept}")
+                        floored = []
                     if floored:
                         below = f"{link.strategy}: below the floor: {', '.join(floored)}"
                         self._say(f"rejected {below}")
@@ -598,6 +638,10 @@ class Pipeline:
         above_floor: list[tuple[Any, ProbeResult]] = []
         for link, measured in probed:
             floored = self.floor.violations(measured)
+            kept = self.floor.kept_below(measured, floored)
+            if kept:
+                self._say(f"{link.strategy} {kept}")
+                floored = []
             if floored:
                 self._say(f"rejected {link.strategy}: below the floor: {', '.join(floored)}")
                 below = f"{link.strategy}: below the floor: {', '.join(floored)}"

{letify-2.2.0 → letify-2.4.0}/letify-core/Cargo.lock

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

{letify-2.2.0 → letify-2.4.0}/letify-core/Cargo.toml

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

{letify-2.2.0 → letify-2.4.0}/letify-ext/package-lock.json

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

{letify-2.2.0 → letify-2.4.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.2.0",
+  "version": "2.4.0",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

{letify-2.2.0 → letify-2.4.0}/pyproject.toml

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

{letify-2.2.0 → letify-2.4.0}/tests/conftest.py

@@ -1693,6 +1693,15 @@ class FakeKaggleCLI:
         self.calls: list[list[str]] = []
         self.environments: list[dict[str, str]] = []
         self.fail: set[str] = set()
+        #: Standard output a ``kernels list --csv`` call answers with. Kaggle names a
+        #: notebook itself, so the titles are its own and the record is what tells
+        #: letify's notebooks from the user's.
+        self.kernels_csv = (
+            "ref,title,author,lastRunTime,totalVotes\n"
+            "irack000/letify-runtime,notebook8843ff70eb,irack000,2026-10-10 05:00:00,0\n"
+            "irack000/my-analysis,My analysis,irack000,2026-10-09 11:00:00,3\n"
+            "irack000/letify-runtime-2,notebook77c1a2,irack000,2026-10-10 06:00:00,0\n"
+        )
         #: Standard output a ``quota`` call answers with, as JSON text.
         self.quota_json = json.dumps([
             {"resource": "GPU", "used": "0.00h", "remaining": "60.00h", "total": "60.00h",
@@ -1712,6 +1721,8 @@ class FakeKaggleCLI:
                 return FakeCompleted(returncode=1, stdout="", stderr="refused")
         if "quota" in command:
             return FakeCompleted(returncode=0, stdout=self.quota_json, stderr="")
+        if "list" in command:
+            return FakeCompleted(returncode=0, stdout=self.kernels_csv, stderr="")
         return FakeCompleted(returncode=0, stdout="{}", stderr="")
 
 

{letify-2.2.0 → letify-2.4.0}/tests/test_elice.py

@@ -841,7 +841,11 @@ def test_a_refused_spot_launch_ends_nothing(account, fake_eci, capsys) -> None:
         }
     )
     Path("pyproject.toml").write_text("[project]\nname = 'study'\n", encoding="utf-8")
-    Path("uv.lock").write_text("", encoding="utf-8")
+    # Names cloudpickle because a lock naming neither it nor letify is refused before
+    # the launch, and this test is about the launch being refused.
+    Path("uv.lock").write_text(
+        'version = 1\n\n[[package]]\nname = "cloudpickle"\n', encoding="utf-8"
+    )
     provider = account()
     instance = Instance(provider, gpu="A100").priced("spot")._placed("remote")
     with pytest.raises(letify.ProviderUnavailable):