letify 2.2.0__tar.gz → 2.3.0__tar.gz

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

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

{letify-2.2.0 → letify-2.3.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.3.0}/letify/providers/base.py

@@ -354,10 +354,48 @@ 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 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.3.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.3.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/"
@@ -504,6 +512,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 +565,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 +717,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
 
@@ -1025,6 +1147,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"
 

{letify-2.2.0 → letify-2.3.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.3.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.3.0}/letify-core/Cargo.lock

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

{letify-2.2.0 → letify-2.3.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.3.0"
 edition = "2024"
 license = "MIT"
 repository = "https://github.com/DarkPyonix/letify"

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

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

{letify-2.2.0 → letify-2.3.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.3.0",
   "publisher": "darkpyonix",
   "license": "SEE LICENSE IN LICENSE",
   "repository": {

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

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

{letify-2.2.0 → letify-2.3.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.3.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):

{letify-2.2.0 → letify-2.3.0}/tests/test_kaggle.py

@@ -295,7 +295,7 @@ def kaggle_provider():
     return provider_of(Kaggle, "kaggle_a")
 
 
-@pytest.mark.parametrize("name, devices", [("T4", 2), ("P100", 1)])
+@pytest.mark.parametrize("name, devices", [("T4", 2)])
 def test_a_kaggle_gpu_instance_declares_its_card_count(name, devices) -> None:
     """Spec "Kaggle": the stable GPU names carry their session's card count."""
     instance = getattr(kaggle_provider(), name)
@@ -460,7 +460,7 @@ def test_the_online_check_is_not_repeated_within_the_liveness_ttl(fake_kaggle) -
 def test_declaring_host_local_on_kaggle_fails_at_decoration(let) -> None:
     import letify
 
-    device = kaggle_provider().P100
+    device = kaggle_provider().T4
     with pytest.raises(letify.UnsupportedMode, match="host='remote'"):
 
         @let.function(device=device)
@@ -488,7 +488,6 @@ def test_the_generated_types_mark_kaggle_accelerators_remote_only(isolated_home)
     (isolated_home / ".letify" / "config.toml").write_text('[kg]\nkind = "kaggle"\n')
     text = stubs.render(letify.Launcher(announce=False))
     body = text.split("class Kg(")[1].split("\nclass ")[0]
-    assert "    P100: letify.declare.instance.RemoteOnlyInstance" in body
     assert ": Instance" not in body
 
 
@@ -560,7 +559,6 @@ def session_channel(fake_kaggle, name: str = "letify-t4-1"):
 @pytest.mark.parametrize("name, accelerator", [
     ("TPU_V3_8", "TPU_V3_8"),
     ("T4", "NVIDIA_TESLA_T4"),
-    ("P100", "NVIDIA_TESLA_P100"),
     ("CPU", None),
 ])
 def test_a_kaggle_instance_requests_its_declared_accelerator(
@@ -1124,3 +1122,113 @@ def test_a_stored_token_with_a_newline_authenticates_cli_deletion(
     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
+
+
+def test_a_kaggle_session_states_the_cards_it_requires() -> None:
+    """Spec "Kaggle": T4 expects two cards whose model contains T4."""
+    from letify.declare.instance import Instance
+
+    provider = kaggle_provider()
+    assert provider.expected_cards(Instance(provider, gpu="T4")) == ("T4", 2)
+    assert provider.expected_cards(Instance(provider, gpu=None)) is None
+
+
+def test_a_card_that_is_not_the_one_asked_for_is_refused(monkeypatch) -> None:
+    """Spec "Kaggle": a request answered with another card does not run.
+
+    Kaggle answered two live P100 requests with two T4s, which is how a declaration
+    stopped saying where the function runs.
+    """
+    from letify.errors import InsufficientDevices
+    from letify.runtime.session import Runtime
+
+    provider = kaggle_provider()
+    session = object.__new__(Runtime)
+    session.name = "letify-t4-1"
+    session.provider = provider
+    session.instance = type("I", (), {"gpu": "T4", "accelerator": "T4"})()
+    monkeypatch.setattr(Runtime, "eval", lambda self, source, timeout=None: ["Tesla P100"])
+    with pytest.raises(InsufficientDevices) as failure:
+        session.check_devices()
+    message = str(failure.value)
+    assert "2 x T4" in message
+    assert "Tesla P100" in message
+    assert "any_accelerator" in message
+
+
+def test_the_cards_that_were_asked_for_pass(monkeypatch) -> None:
+    """Spec "Kaggle": the right name and the right count is what passes."""
+    from letify.runtime.session import Runtime
+
+    provider = kaggle_provider()
+    session = object.__new__(Runtime)
+    session.name = "letify-t4-2"
+    session.provider = provider
+    session.instance = type("I", (), {"gpu": "T4", "accelerator": "T4"})()
+    monkeypatch.setattr(
+        Runtime, "eval", lambda self, source, timeout=None: ["Tesla T4", "Tesla T4"]
+    )
+    session.check_devices()
+
+
+def test_the_notebooks_letify_recorded_are_listed_and_the_user_s_own_are_not(
+    fake_kaggle_cli, kaggle_api_token, config_file
+) -> None:
+    """Spec "Kaggle", finding the notebooks letify owns.
+
+    Kaggle names the notebook itself, confirmed on a live account where one letify created
+    was titled `notebook8843ff70eb`, so the local record is what identifies them. A process
+    that dies before stop leaves its notebook holding weekly quota with nothing pointing at
+    it, and this is how it is found.
+    """
+    from letify.providers.kaggle import record_notebook
+
+    provider = kaggle_provider()
+    assert provider.discovers_sessions is True
+    record_notebook("kaggle_a", "letify-runtime")
+    record_notebook("kaggle_a", "letify-runtime-2")
+    assert provider.sessions() == ["irack000/letify-runtime", "irack000/letify-runtime-2"]
+    listed = [call for call in fake_kaggle_cli.calls if "list" in call]
+    assert listed and "--mine" in listed[0]
+    assert fake_kaggle_cli.environments[0].get("KAGGLE_API_TOKEN")
+
+
+def test_a_notebook_deleted_elsewhere_is_dropped_from_the_record(
+    fake_kaggle_cli, kaggle_api_token, config_file
+) -> None:
+    """Spec: a ref the account no longer has was deleted elsewhere, so it is not reported."""
+    from letify.providers.kaggle import record_notebook, recorded_notebooks
+
+    provider = kaggle_provider()
+    record_notebook("kaggle_a", "letify-runtime")
+    record_notebook("kaggle_a", "gone-already")
+    assert provider.sessions() == ["irack000/letify-runtime"]
+    assert recorded_notebooks("kaggle_a") == ["irack000/letify-runtime"]
+
+
+def test_nothing_is_reported_when_letify_recorded_nothing(
+    fake_kaggle_cli, kaggle_api_token, config_file
+) -> None:
+    """Spec: a notebook created before letify kept this record is not in it."""
+    assert kaggle_provider().sessions() == []
+
+
+def test_listing_notebooks_without_an_api_token_is_empty_rather_than_a_failure(
+    fake_kaggle_cli, isolated_home, config_file
+) -> None:
+    """Spec: reading what exists must not fail a command that is asking what exists."""
+    from letify.providers.kaggle import notebook_record
+
+    path = notebook_record("kaggle_a")
+    path.parent.mkdir(mode=0o700, parents=True, exist_ok=True)
+    path.write_text("irack000/letify-runtime\n", encoding="utf-8")
+    assert kaggle_provider().sessions() == []
+
+
+def test_a_kaggle_account_is_asked_for_its_sessions(launcher_from, fake_kaggle_cli) -> None:
+    """Spec: whether an account can be asked is the provider's answer, not the launcher's."""
+    let = launcher_from('[kaggle_a]\nkind = "kaggle"\n')
+    rows = {row["alias"]: row for row in let.sessions()}
+    row = rows.get("kaggle_a")
+    assert row is not None, rows
+    assert row.get("reason") != "session discovery is not supported"

{letify-2.2.0 → letify-2.3.0}/tests/test_kaggle_link.py

@@ -299,3 +299,21 @@ def test_a_kaggle_session_on_the_bridge_offers_no_transfer_channel() -> None:
     assert provider.link(Runtime()) is None
     with pytest.raises(UnsupportedMode):
         provider.transfer_channel(Runtime())
+
+
+def test_kaggle_does_not_offer_the_retired_p100() -> None:
+    """Spec "Kaggle": Kaggle retired the P100 on 2026-09-15 and substitutes T4x2.
+
+    Two live accounts asking for P100 both received two T4s. A declaration states where a
+    function runs, so the name is refused rather than silently answered with another card.
+    """
+    from letify.errors import UnknownInstance
+
+    provider = kaggle()
+    assert "P100" not in provider.discover()
+    assert "T4" in provider.discover()
+    with pytest.raises(UnknownInstance) as failure:
+        provider.device("P100")
+    message = str(failure.value)
+    assert "2026-09-15" in message
+    assert "T4" in message