letify 2.8.0__tar.gz → 2.8.1__tar.gz

{letify-2.8.0 → letify-2.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: letify
-Version: 2.8.0
+Version: 2.8.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

{letify-2.8.0 → letify-2.8.1}/docs/SPEC.md

@@ -1565,6 +1565,8 @@ Both run in two places with the same result:
 
 A body run on a one-shot channel, which has no stream back to the local process, cannot ask for a grant, so `stash` and `unstash` there raise `UnsupportedMode` naming the provider rather than reading the runtime's own configuration.
 
+The worker sets the environment variable `LETIFY_WORKER_PID` to its process id, so a process the body starts, such as one per GPU, inherits it without the grant hook. `stash` and `unstash` called there raise `UnsupportedMode` naming the handoff, saying the call must be made from the process letify runs the body in and not from a child process it started, and neither reads the configuration nor touches Drive.
+
 When the machine declares no Drive store, both raise `ConfigError` naming `drive_login` and `drive_project`. letify never falls back to another store or to the local disk. A Drive request that fails raises `RuntimeFailure` naming the Drive status and the name, and the function body decides whether to carry on.
 
 ## Environment
@@ -1914,6 +1916,8 @@ The key is per session. letify generates a new ed25519 key pair for each session
 
 The Colab CLI runs as `uv tool run --from google-colab-cli colab`, with `jupyter-kernel-client<1` pinned, because release 0.6.0 of the CLI calls an API that jupyter-kernel-client 1.0 removed. `colab new` and `colab stop` manage the session. `Colab.sessions()` reads `colab sessions` and returns the first word of each listing line. The CLI prints a session as `[<name>] <id> | Hardware: <hardware> | Variant: <variant>`, so a first word in square brackets gives the name inside them. A line starting with `[colab]` is a message from the CLI, such as `[colab] No active sessions found on server.`, and names no session, so an account with no session returns an empty list.
 
+**An assignment with no session.** `colab new` can fail after Colab has already assigned a machine, for example with `ReadTimeout` after 120 s, and the machine then bills (14.2 compute units per hour for an A100) with no local session state. `colab sessions` lists it as `[?] <endpoint> | ...`, and `colab stop -s <name>` cannot reach it. `Colab.create_session` therefore lists the account's assignments before `colab new`. When `colab new` raises, for any reason, it lists them again, releases every `?` assignment whose endpoint was not in the first list, and re-raises the original error. An assignment that existed before the attempt is never released. Each release prints one line on standard error naming the endpoint. When the first or the second listing fails, one line on standard error names the endpoint check and the error, and the original error is still the one raised. An assignment is released by endpoint with `Client.unassign` of the Colab CLI, run as `uv tool run --from google-colab-cli python -c <script> <endpoint>` with the account's environment, because the CLI has no command for it. `Colab.orphans()` returns the endpoints of the `?` rows of `colab sessions` and `Colab.stop_orphan(endpoint)` releases one, so `letify stop --orphans` covers Colab as it covers Kaggle.
+
 **Runtime tools.** A runtime whose rendezvous runs a Python program on the machine, Colab and Kaggle both, installs tailcat lazily when the tailcat strategy requests its endpoint, within that strategy's race thread. The install belongs to the rendezvous and not to one provider, so a provider that leaves it out is a defect rather than a choice: without it the tailcat request carries no path, the remote side runs a bare `tailcat`, and the strategy fails with `FileNotFoundError` on a runtime image that ships no such binary. Target construction performs no remote installation. TCP punch rendezvous never waits for tailcat preparation, even if installation fails or takes its full 180 second timeout. A locally available `tailcat` or configured `tailcat_binary` requires the Linux release pinned by `letify.install.TAILCAT_VERSION`, `TAILCAT_RELEASE` and `TAILCAT_SHA256`. The runtime selects its own architecture, verifies the archive SHA-256, extracts only a regular `tailcat` member into `~/.letify/tools/tailcat/<version>/tailcat`, and verifies the cached binary against its recorded SHA-256 on reuse. Only tailcat requests carry that absolute path. Installation errors name the tool and verification failure and fail that strategy. Tailcat remains eligible because throughput is measured per link rather than inferred from another session. The shared account throughput floor still rejects slow links.
 
 **Rendezvous scheduling.** Provider `colab exec` commands, including TCP punch rendezvous and tailcat preparation, do not acquire the wake lock. The lock protects concurrent wakes sharing CLI session state; rendezvous is a separate operation whose agreed dial time cannot wait behind a wake's 120 second timeout. Wakes acquire the account lock without waiting. If another wake holds it, the daemon records `wake_skipped` with reason `account_busy`, logs the skip and waits 60 seconds before trying again. Successful acquisition still holds the lock through the wake command so two wakes cannot collide. An already running wake cannot hold a lock needed by a connection.

{letify-2.8.0 → letify-2.8.1}/letify/__init__.py

@@ -68,7 +68,7 @@ distributed: Final = Host.distributed
 # The enum class stays importable from letify.declare.instance for letify's own use.
 del Host
 
-__version__ = "2.8.0"
+__version__ = "2.8.1"
 
 
 def fetch(tensor):  # type: ignore[no-untyped-def]

{letify-2.8.0 → letify-2.8.1}/letify/protocol/worker.py

@@ -1346,6 +1346,11 @@ _DRIVE_LOCK = threading.Condition()
 #: ``stash`` or ``unstash`` takes them.
 _DRIVE_ANSWERS = {}
 
+# A process the body starts inherits this and lacks ``_drive_ask``, which is how
+# ``stash`` and ``unstash`` tell it is a child of the body and refuse. Spec "Named handoffs
+# on the Drive store".
+os.environ["LETIFY_WORKER_PID"] = str(os.getpid())
+
 
 def _drive_ask(message):
     """Ask the client for a Drive grant. Nothing replies to this request.

{letify-2.8.0 → letify-2.8.1}/letify/providers/colab.py

@@ -121,6 +121,28 @@ def _access_token(stored: dict[str, Any]) -> str:
         return str(json.loads(response.read())["access_token"])
 
 
+#: Run in the CLI's own Python: release the server-side assignment at the endpoint in argv.
+#: ``colab stop`` cannot do this, because it needs the local session state an assignment
+#: made by a failed ``colab new`` never got. Spec "Colab", an assignment with no session.
+UNASSIGN_SCRIPT = (
+    "import sys\n"
+    "from colab_cli.common import state\n"
+    "state.client.unassign(sys.argv[1])\n"
+)
+
+
+def _parse_assignments(listing: str) -> list[tuple[str, str]]:
+    """The ``(name, endpoint)`` pairs in ``colab sessions`` output, ``?`` for no local state."""
+    found = []
+    for line in listing.splitlines():
+        head = line.strip().split("|")[0].split()
+        if len(head) >= 2 and head[0].startswith("[") and head[0].endswith("]"):
+            name = head[0][1:-1]
+            if name.lower() != "colab":
+                found.append((name, head[1]))
+    return found
+
+
 class Colab(Shell):
     """A Colab runtime for one Google account."""
 
@@ -316,6 +338,68 @@ class Colab(Shell):
                 names.append(word)
         return names
 
+    def _assignments(self) -> list[tuple[str, str]]:
+        """Every assignment the account holds, as ``(name, endpoint)``; ``?`` has no local state."""
+        return _parse_assignments(self._cli("sessions", timeout=120))
+
+    def _unassign(self, endpoint: str) -> None:
+        """Release one assignment by endpoint, through the CLI's own client library."""
+        uv = tools.find_uv()
+        if uv is None:
+            raise ProviderUnavailable(self.kind, tools.missing_uv_message())
+        command = [*tools.python_command(tools.COLAB, uv), "-c", UNASSIGN_SCRIPT, endpoint]
+        result = subprocess.run(
+            command, capture_output=True, text=True, timeout=180, env=self._env()
+        )
+        if result.returncode != 0:
+            raise RuntimeFailure(
+                f"unassigning {endpoint} exited {result.returncode}",
+                command=" ".join(command[:-3]),
+                stderr=(result.stderr or "").strip(),
+            )
+
+    def orphans(self) -> list[str]:
+        """Endpoints of assignments the account holds that no local session names."""
+        return [endpoint for name, endpoint in self._assignments() if name == "?"]
+
+    def stop_orphan(self, ref: str) -> bool:
+        """Unassign one endpoint `orphans` reported, and report whether it is gone."""
+        try:
+            self._unassign(ref)
+        except (RuntimeFailure, ProviderUnavailable, subprocess.TimeoutExpired):
+            return False
+        return True
+
+    def _release_leftovers(self, before: set[str]) -> None:
+        """Unassign each `?` assignment that appeared since ``before``, best effort."""
+        try:
+            leftovers = [
+                endpoint
+                for name, endpoint in self._assignments()
+                if name == "?" and endpoint not in before
+            ]
+        except (RuntimeFailure, ProviderUnavailable, subprocess.TimeoutExpired) as exc:
+            print(
+                f"letify: {self.alias}: the endpoint check after the failed 'colab new' "
+                f"could not list assignments ({exc}); an assignment may still be billing, "
+                "see 'letify stop --orphans'",
+                file=sys.stderr,
+            )
+            return
+        for endpoint in leftovers:
+            if self.stop_orphan(endpoint):
+                print(
+                    f"letify: {self.alias}: released {endpoint}, assigned by the failed "
+                    "'colab new'",
+                    file=sys.stderr,
+                )
+            else:
+                print(
+                    f"letify: {self.alias}: could not release {endpoint}, assigned by the "
+                    "failed 'colab new'; run 'letify stop --orphans'",
+                    file=sys.stderr,
+                )
+
     # -- the pipeline ----------------------------------------------------------
 
     def strategies(self) -> list[Strategy]:
@@ -388,7 +472,22 @@ class Colab(Shell):
             args += ["--gpu", ALIASES.get(instance.gpu, instance.gpu)]
         elif instance.tpu:
             args += ["--tpu", instance.tpu]
-        self._cli(*args, timeout=900)
+        try:
+            before = {endpoint for _, endpoint in self._assignments()}
+        except (RuntimeFailure, subprocess.TimeoutExpired) as exc:
+            before = None
+            print(
+                f"letify: {self.alias}: the endpoint check before 'colab new' could not "
+                f"list assignments ({exc}); a failed creation will not be cleaned up",
+                file=sys.stderr,
+            )
+        try:
+            self._cli(*args, timeout=900)
+        except BaseException:
+            # A timed out `colab new` can still leave a server-side assignment behind.
+            if before is not None:
+                self._release_leftovers(before)
+            raise
         try:
             self._start_keep_alive(name)
         except BaseException:

{letify-2.8.0 → letify-2.8.1}/letify/store/handoff.py

@@ -35,6 +35,10 @@ from ..protocol import codec
 #: so a body can tell it runs on a channel with no stream back to the local process.
 ONE_SHOT_MARKER = "LETIFY_ONE_SHOT"
 
+#: The environment variable the worker sets to its process id, so a child process of the
+#: body, which inherits it but lacks the worker's grant hook, can say why it cannot ask.
+WORKER_MARKER = "LETIFY_WORKER_PID"
+
 #: The prefix of a handoff's ref, so handoffs share the folder with other refs.
 REF_SPACE = "stash/"
 
@@ -198,7 +202,7 @@ def stash(name: str, path: str | os.PathLike[str]) -> str:
     source = Path(path)
     if not source.exists():
         raise FileNotFoundError(f"cannot stash {str(source)!r}: it does not exist")
-    main = _worker_main()
+    main = _worker_main(name)
     if main is not None:
         return _stash_in_worker(main, name, source)
     backend = drive_backend()
@@ -222,7 +226,7 @@ def unstash(name: str, path: str | os.PathLike[str]) -> Path | None:
     """
     check_name(name)
     target = Path(path)
-    main = _worker_main()
+    main = _worker_main(name)
     if main is not None:
         return _unstash_in_worker(main, name, target)
     backend = drive_backend()
@@ -255,7 +259,7 @@ def _verify(name: str, archive: Path, digest: str) -> None:
 # -- inside a shipped function ---------------------------------------------------------
 
 
-def _worker_main() -> Any:
+def _worker_main(name: str) -> Any:
     """The worker's ``__main__`` module when this runs inside a shipped function, else None.
 
     The same test ``all_reduce`` makes: only the worker defines the hook that sends a request
@@ -264,6 +268,13 @@ def _worker_main() -> Any:
     main = sys.modules.get("__main__")
     if main is not None and hasattr(main, "_drive_ask"):
         return main
+    worker_pid = os.environ.get(WORKER_MARKER)
+    if worker_pid is not None and worker_pid != str(os.getpid()):
+        raise UnsupportedMode(
+            f"handoff {name!r}: stash and unstash must be called from the process letify "
+            f"runs the body in, not from a child process it started (this is a child of "
+            f"worker process {worker_pid}). Call it in the body and pass the path to the child."
+        )
     one_shot = os.environ.get(ONE_SHOT_MARKER)
     if one_shot is not None:
         raise UnsupportedMode(

{letify-2.8.0 → letify-2.8.1}/letify/tools.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 import os
 import shutil
 import sys
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from pathlib import Path
 
 from .config.secrets import account_directory
@@ -111,6 +111,15 @@ def command(tool: Tool, uv: str) -> list[str]:
     ]
 
 
+def python_command(tool: Tool, uv: str) -> list[str]:
+    """The argument list that runs the Python of ``tool``'s own uv environment.
+
+    Code run this way can import the tool's package, which is how a call the tool's command
+    line does not offer reaches the tool's client library.
+    """
+    return command(replace(tool, executable="python"), uv)
+
+
 def _ensure_symlink(link_path: Path, target: Path) -> None:
     link_path.parent.mkdir(parents=True, exist_ok=True)
     if link_path.is_symlink() or link_path.exists():

{letify-2.8.0 → letify-2.8.1}/letify-core/Cargo.lock

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

{letify-2.8.0 → letify-2.8.1}/letify-core/Cargo.toml

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

{letify-2.8.0 → letify-2.8.1}/letify-ext/package-lock.json

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

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

{letify-2.8.0 → letify-2.8.1}/pyproject.toml

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

{letify-2.8.0 → letify-2.8.1}/tests/conftest.py

@@ -2016,3 +2016,41 @@ def kaggle_api_token(isolated_home):
     write_secret("kaggle_a", "username", "irack000")
     return write_secret("kaggle_a", "access_token", "KGAT_" + "a" * 32)
 
+
+
+class FakeColabCli:
+    """A Colab CLI that holds assignments, for ``patch_run`` as the ``result`` callable.
+
+    ``sessions`` prints one ``[<name>] <endpoint>`` row per assignment, ``?`` for one with
+    no local state. ``new`` can add an assignment and then fail, as a read timeout does.
+    The unassign script is recognized by its ``python`` executable and removes the endpoint
+    named by its last argument.
+    """
+
+    def __init__(self, assignments=(), new_adds=None, new_fails=False, list_fails_after=None):
+        self.assignments = list(assignments)
+        self.new_adds = new_adds
+        self.new_fails = new_fails
+        self.list_fails_after = list_fails_after
+        self.listings = 0
+        self.unassigned: list[str] = []
+
+    def __call__(self, command):
+        if "python" in command and "-c" in command:
+            self.unassigned.append(command[-1])
+            self.assignments = [a for a in self.assignments if a[1] != command[-1]]
+            return FakeCompleted()
+        if "sessions" in command:
+            self.listings += 1
+            if self.list_fails_after is not None and self.listings > self.list_fails_after:
+                return FakeCompleted(returncode=1, stderr="Read timed out")
+            rows = [f"[{n}] {e} | Hardware: A100 | Variant: GPU\n" for n, e in self.assignments]
+            return FakeCompleted(
+                stdout="".join(rows) or "[colab] No active sessions found on server.\n"
+            )
+        if "new" in command:
+            if self.new_adds:
+                self.assignments.append(("?", self.new_adds))
+            if self.new_fails:
+                return FakeCompleted(returncode=1, stderr="ReadTimeout: Read timed out")
+        return FakeCompleted()

{letify-2.8.0 → letify-2.8.1}/tests/test_drive_handoff.py

@@ -425,3 +425,77 @@ def test_stash_and_unstash_on_a_one_shot_channel_raise_unsupported_mode_naming_t
     assert len(value) == 2
     assert all("colab_a" in message for message in value)
     assert fake_drive.requests == []
+
+
+# -- a child process of the body -------------------------------------------------------
+
+
+def test_stash_and_unstash_in_a_child_process_of_the_body_say_to_call_from_the_main_process(
+    fake_drive, launcher_from, tmp_path, worker_sees_this_checkout
+) -> None:
+    """Spec: a child the body starts has no grant hook, so it raises instead of reading config."""
+    declare_drive(fake_drive)
+    let = launcher_from(LOCAL)
+    source = tmp_path / "f.txt"
+    source.write_text("x")
+
+    @let.function(device=let.providers.a.CPU, host=letify.remote)
+    def from_children(path: str) -> dict:
+        import multiprocessing
+        import os
+        import subprocess
+        import sys
+        from pathlib import Path
+
+        import letify as inner
+
+        code = (
+            "import sys, letify\n"
+            "for call in (lambda: letify.stash('kid', sys.argv[1]),"
+            " lambda: letify.unstash('kid', sys.argv[1] + '.out')):\n"
+            "    try:\n"
+            "        call()\n"
+            "    except letify.UnsupportedMode as exc:\n"
+            "        print('UM:' + str(exc))\n"
+        )
+        run = subprocess.run(
+            [sys.executable, "-c", code, path], capture_output=True, text=True, check=True
+        )
+        helper = Path(path).parent / "spawned_helper.py"
+        helper.write_text(
+            "import letify\n"
+            "def unstash_it(queue, path):\n"
+            "    try:\n"
+            "        letify.unstash('spawned', path)\n"
+            "    except letify.UnsupportedMode as exc:\n"
+            "        queue.put(str(exc))\n"
+            "    else:\n"
+            "        queue.put('no error')\n"
+        )
+        sys.path.insert(0, str(helper.parent))
+        old = os.environ.get("PYTHONPATH", "")
+        os.environ["PYTHONPATH"] = str(helper.parent) + os.pathsep + old
+        import spawned_helper
+
+        context = multiprocessing.get_context("spawn")
+        queue = context.Queue()
+        process = context.Process(target=spawned_helper.unstash_it, args=(queue, path + ".spawn"))
+        process.start()
+        spawned = queue.get(timeout=120)
+        process.join()
+        return {
+            "subprocess": [x for x in run.stdout.splitlines() if x.startswith("UM:")],
+            "spawn": spawned,
+            "main_is_not_refused": inner.UnsupportedMode.__name__,
+        }
+
+    with let.keep_alive():
+        answer = from_children(str(source))
+    assert len(answer["subprocess"]) == 2
+    for message in answer["subprocess"] + [answer["spawn"]]:
+        assert "process letify runs the body in" in message
+        assert "child process" in message
+    assert "'kid'" in answer["subprocess"][0] and "'kid'" in answer["subprocess"][1]
+    assert "'spawned'" in answer["spawn"]
+    assert fake_drive.requests == []
+

{letify-2.8.0 → letify-2.8.1}/tests/test_providers.py

@@ -20,7 +20,7 @@ from importlib import import_module
 from pathlib import Path
 
 import pytest
-from conftest import FakeCompleted, FakeResponse, provider_of
+from conftest import FakeColabCli, FakeCompleted, FakeResponse, provider_of
 
 import letify
 from letify import providers
@@ -3066,3 +3066,73 @@ def test_a_data_channel_failure_names_the_host(isolated_home, fake_modal, capfd)
     finally:
         channel.close()
         provider.stop(runtime)
+
+
+# -- Spec: Colab, an assignment with no session ---------------------------------
+
+
+def _colab_with(patch_which, patch_run, cli):
+    patch_which(tools_module, present=True)
+    patch_run(colab_module, result=cli)
+    return provider_of(Colab, "colab_a")
+
+
+def test_a_failed_colab_new_that_left_an_assignment_unassigns_it_and_reraises(
+    isolated_home, patch_which, patch_run, capsys
+) -> None:
+    cli = FakeColabCli(new_adds="gpu-a100-new", new_fails=True)
+    provider = _colab_with(patch_which, patch_run, cli)
+    with pytest.raises(letify.RuntimeFailure, match=r"ReadTimeout|exited 1"):
+        provider.create_session(provider.A100, "letify-a100-1")
+    assert cli.unassigned == ["gpu-a100-new"]
+    assert "gpu-a100-new" in capsys.readouterr().err
+
+
+def test_an_assignment_that_existed_before_a_failed_colab_new_is_left_alone(
+    isolated_home, patch_which, patch_run
+) -> None:
+    cli = FakeColabCli(assignments=[("?", "gpu-old")], new_fails=True)
+    provider = _colab_with(patch_which, patch_run, cli)
+    with pytest.raises(letify.RuntimeFailure):
+        provider.create_session(provider.A100, "letify-a100-1")
+    assert cli.unassigned == []
+
+
+def test_a_failed_colab_new_does_not_unassign_a_session_with_a_name(
+    isolated_home, patch_which, patch_run
+) -> None:
+    cli = FakeColabCli(new_fails=True)
+    cli.assignments.append(("letify-other", "gpu-named"))
+    provider = _colab_with(patch_which, patch_run, cli)
+    with pytest.raises(letify.RuntimeFailure):
+        provider.create_session(provider.A100, "letify-a100-1")
+    assert cli.unassigned == []
+
+
+def test_a_failed_endpoint_check_is_reported_and_the_original_error_is_raised(
+    isolated_home, patch_which, patch_run, capsys
+) -> None:
+    cli = FakeColabCli(new_fails=True, list_fails_after=1)
+    provider = _colab_with(patch_which, patch_run, cli)
+    with pytest.raises(letify.RuntimeFailure, match=r"colab_a|new"):
+        provider.create_session(provider.A100, "letify-a100-1")
+    assert "endpoint check" in capsys.readouterr().err
+    assert cli.unassigned == []
+
+
+def test_colab_orphans_are_the_endpoints_with_no_local_session(
+    isolated_home, patch_which, patch_run
+) -> None:
+    cli = FakeColabCli(assignments=[("?", "gpu-a"), ("letify-x", "gpu-b"), ("?", "gpu-c")])
+    provider = _colab_with(patch_which, patch_run, cli)
+    assert provider.orphans() == ["gpu-a", "gpu-c"]
+
+
+def test_stopping_a_colab_orphan_unassigns_its_endpoint(
+    isolated_home, patch_which, patch_run
+) -> None:
+    cli = FakeColabCli(assignments=[("?", "gpu-a")])
+    provider = _colab_with(patch_which, patch_run, cli)
+    assert provider.stop_orphan("gpu-a") is True
+    assert cli.unassigned == ["gpu-a"]
+    assert provider.orphans() == []