google-colab-cli 0.5.4__py3-none-any.whl

colab_cli/runtime.py

@@ -0,0 +1,262 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import logging
+import time
+from typing import Any, Callable, Dict, List, Optional
+
+import jupyter_kernel_client
+import requests
+
+
+class ColabRuntime:
+    def __init__(
+        self,
+        url: str,
+        token: str,
+        session_name: Optional[str] = None,
+        history: Optional[Any] = None,
+        kernel_id: Optional[str] = None,
+        session_id: Optional[str] = None,
+        on_kernel_started: Optional[Callable[[str], None]] = None,
+        on_session_started: Optional[Callable[[str], None]] = None,
+    ):
+        self.url = url
+        self.token = token
+        self.session_name = session_name
+        self.history = history
+        self.kernel_id = kernel_id
+        self.session_id = session_id
+        self.on_kernel_started = on_kernel_started
+        self.on_session_started = on_session_started
+        self._kernel_client = None
+        self.colab_request_hook: Optional[Callable[[Dict[str, Any], Any], None]] = None
+
+    def _apply_ws_hook(self):
+        wsclient = self._kernel_client._manager.client
+        original_on_message = wsclient.kernel_socket.on_message
+
+        def hooked_on_message(s_ws, message):
+            if not self.colab_request_hook:
+                return original_on_message(s_ws, message)
+
+            try:
+                from jupyter_kernel_client.wsclient import JupyterSubprotocol
+
+                if wsclient._subprotocol == JupyterSubprotocol.DEFAULT:
+                    from jupyter_kernel_client.wsclient import (
+                        deserialize_msg_from_ws_default,
+                    )
+
+                    deserialize_msg = deserialize_msg_from_ws_default(message)
+                elif wsclient._subprotocol == JupyterSubprotocol.V1:
+                    from jupyter_kernel_client.wsclient import (
+                        deserialize_msg_from_ws_v1,
+                    )
+
+                    channel, msg_list = deserialize_msg_from_ws_v1(message)
+                    deserialize_msg = wsclient.session.deserialize(msg_list)
+                else:
+                    deserialize_msg = None
+
+                if deserialize_msg:
+                    msg_type = deserialize_msg.get("msg_type")
+                    if msg_type == "colab_request":
+                        # We pass the deserialized msg and the wsclient to the hook
+                        if self.colab_request_hook(deserialize_msg, wsclient):
+                            # If the hook returns True, we intercept and do NOT pass to original
+                            return
+
+            except Exception as e:
+                logging.debug(f"Error in colab_request hook: {e}")
+
+            # Call original for all other messages
+            original_on_message(s_ws, message)
+
+        wsclient.kernel_socket.on_message = hooked_on_message
+
+    @property
+    def kernel_client(self):
+        if not self._kernel_client:
+            retries = 3
+            backoff = 2
+            last_err = None
+
+            for i in range(retries):
+                try:
+                    client_kwargs = {
+                        "subprotocol": jupyter_kernel_client.JupyterSubprotocol.DEFAULT,
+                        "extra_params": {"colab-runtime-proxy-token": self.token},
+                    }
+                    if self.session_id:
+                        # WSSession (Session) expects 'session' for the ID
+                        client_kwargs["session"] = self.session_id
+
+                    self._kernel_client = jupyter_kernel_client.KernelClient(
+                        server_url=self.url,
+                        token=self.token,
+                        kernel_id=self.kernel_id,
+                        client_kwargs=client_kwargs,
+                        headers={
+                            "X-Colab-Client-Agent": "colab-cli",
+                            "X-Colab-Runtime-Proxy-Token": self.token,
+                        },
+                    )
+                    # Force _own_kernel to False. This prevents jupyter-kernel-client
+                    # from automatically deleting the kernel when the client is closed or deleted.
+                    self._kernel_client._own_kernel = False
+
+                    self._kernel_client.start()
+                    self._apply_ws_hook()
+
+                    # Capture IDs if we started fresh
+                    if not self.kernel_id and self._kernel_client.id:
+                        self.kernel_id = self._kernel_client.id
+                        if self.on_kernel_started:
+                            self.on_kernel_started(self.kernel_id)
+
+                    if (
+                        not self.session_id
+                        and self._kernel_client._manager.client.session.session
+                    ):
+                        self.session_id = (
+                            self._kernel_client._manager.client.session.session
+                        )
+                        if self.on_session_started:
+                            self.on_session_started(self.session_id)
+                    break
+                except (
+                    requests.exceptions.ReadTimeout,
+                    requests.exceptions.ConnectTimeout,
+                ) as e:
+                    last_err = e
+                    if i < retries - 1:
+                        sleep_time = backoff ** (i + 1)
+                        logging.debug(
+                            f"Kernel startup timeout, retrying in {sleep_time}s..."
+                            f" ({i + 1}/{retries})"
+                        )
+                        time.sleep(sleep_time)
+                    else:
+                        raise last_err
+                except Exception as e:
+                    raise e
+
+        return self._kernel_client
+    
+    def restart(
+        self,
+        timeout: Optional[float] = None,
+    ):
+        self.kernel_client.restart(timeout=timeout)
+
+    def execute_code(
+        self,
+        code: str,
+        allow_stdin: bool = False,
+        stdin_hook: Any = None,
+        output_hook: Optional[Callable[[Dict[str, Any]], None]] = None,
+        timeout: Optional[float] = None,
+    ) -> List[Dict[str, Any]]:
+        # ``jupyter_kernel_client`` defaults ``timeout`` to ``REQUEST_TIMEOUT``
+        # (10 seconds) on both ``execute`` and ``execute_interactive``. That
+        # value is a wall-clock budget that shrinks every time the poll loop
+        # iterates -- as long as iopub/stdin events arrive back-to-back the
+        # call survives, but a single >10s quiet stretch (e.g. a kernel
+        # blocked on ``input_request`` while the user OAuths in the browser)
+        # will raise ``TimeoutError`` even though the underlying execution is
+        # still healthy. Callers that know they need a longer ceiling can
+        # pass ``timeout=`` here; otherwise we forward whatever the upstream
+        # default is (currently 10s).
+        kwargs = {"allow_stdin": allow_stdin}
+        if timeout is not None:
+            kwargs["timeout"] = timeout
+
+        # Wrap stdin_hook to log inputs
+        original_stdin_hook = stdin_hook
+
+        def wrapped_stdin_hook(prompt):
+            if self.history and self.session_name:
+                self.history.log_event(
+                    self.session_name, "stdin_request", {"prompt": prompt}
+                )
+
+            res = original_stdin_hook(prompt) if original_stdin_hook else input(prompt)
+
+            if self.history and self.session_name:
+                self.history.log_event(self.session_name, "input_reply", {"value": res})
+            return res
+
+        if allow_stdin:
+            kwargs["stdin_hook"] = wrapped_stdin_hook
+
+        if output_hook:
+            # If we have an output hook, we use execute_interactive and manage buffering ourselves
+            outputs = []
+
+            def wrapped_output_hook(msg):
+                from jupyter_kernel_client.client import (
+                    output_hook as default_output_hook,
+                )
+
+                # Update local outputs list using the default logic
+                new_indexes = default_output_hook(outputs, msg)
+                # If new outputs were added, call our streaming hook with the new data
+                if new_indexes:
+                    for idx in sorted(new_indexes):
+                        if idx < len(outputs):
+                            output_hook(outputs[idx])
+
+            reply = self.kernel_client.execute_interactive(
+                code, output_hook=wrapped_output_hook, **kwargs
+            )
+            # execute_interactive returns the raw reply message
+            reply_content = reply["content"] if reply else {"status": "error"}
+        else:
+            reply = self.kernel_client.execute(code, **kwargs)
+            if not reply:
+                return []
+            outputs = reply.get("outputs", [])
+            reply_content = reply
+
+        # If there's an error status but no error in outputs, synthesize one
+        if reply_content.get("status") == "error":
+            has_error_output = any(o.get("output_type") == "error" for o in outputs)
+            if not has_error_output:
+                outputs.append(
+                    {
+                        "output_type": "error",
+                        "ename": reply_content.get("ename", "Error"),
+                        "evalue": reply_content.get("evalue", "Unknown error"),
+                        "traceback": reply_content.get("traceback", []),
+                    }
+                )
+
+        return outputs
+
+    def stop(self, shutdown_kernel: bool = False):
+        if self._kernel_client:
+            try:
+                # We manage kernel lifecycle explicitly.
+                # To prevent automatic shutdown, we bypass the manager's stop() and
+                # directly close the channels and socket.
+                client = self._kernel_client._manager.client
+                client.stop_channels()
+                if client.kernel_socket:
+                    client.kernel_socket.close()
+
+                if shutdown_kernel:
+                    self._kernel_client._manager.shutdown_kernel(now=True)
+            except Exception:
+                logging.exception("Error stopping kernel client")

colab_cli/state.py

@@ -0,0 +1,152 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import contextlib
+import json
+import os
+import fcntl
+from datetime import datetime
+from typing import Dict, Optional, Tuple, Iterator, IO
+from pydantic import BaseModel
+
+
+class SessionState(BaseModel):
+    name: str
+    token: str
+    url: str
+    endpoint: str
+    variant: str = "DEFAULT"
+    accelerator: str = "NONE"
+    kernel_id: Optional[str] = None
+    session_id: Optional[str] = None
+    last_execution: Optional[Tuple[str, Optional[str], str]] = None
+    running: Optional[str] = None
+    keep_alive_pid: Optional[int] = None
+
+
+class Settings(BaseModel):
+    update_url: str = "https://pypi.org/pypi/google-colab-cli/json"
+    last_check: Optional[datetime] = None
+    enable_update_check: bool = True
+    # Highest version seen on the update source; cached for the banner.
+    latest_version: Optional[str] = None
+
+
+class _LockedFileStore:
+    def __init__(self, path: str):
+        self.path = path
+        self._ensure_dir()
+
+    def _ensure_dir(self):
+        os.makedirs(os.path.dirname(self.path), exist_ok=True)
+
+    def _write_data(self, f: IO, data: str):
+        f.seek(0)
+        f.truncate()
+        f.write(data)
+        f.flush()
+        os.fsync(f.fileno())
+
+    @contextlib.contextmanager
+    def _lock_shared(self) -> Iterator[Optional[IO]]:
+        if not os.path.exists(self.path):
+            yield None
+            return
+        with open(self.path, "r") as f:
+            fcntl.flock(f, fcntl.LOCK_SH)
+            try:
+                yield f
+            finally:
+                fcntl.flock(f, fcntl.LOCK_UN)
+
+    @contextlib.contextmanager
+    def _lock_exclusive(self) -> Iterator[IO]:
+        with open(self.path, "a+") as f:
+            fcntl.flock(f, fcntl.LOCK_EX)
+            try:
+                yield f
+            finally:
+                fcntl.flock(f, fcntl.LOCK_UN)
+
+
+class SettingsStore(_LockedFileStore):
+    def __init__(self, path: Optional[str] = None):
+        if not path:
+            path = os.path.expanduser("~/.config/colab-cli/settings.json")
+        super().__init__(path)
+
+    def load(self) -> Settings:
+        with self._lock_shared() as f:
+            if f is None:
+                return Settings()
+            try:
+                content = f.read()
+                if not content or content.isspace():
+                    return Settings()
+                data = json.loads(content)
+                return Settings.model_validate(data)
+            except Exception:
+                return Settings()
+
+    def save(self, settings: Settings):
+        with self._lock_exclusive() as f:
+            self._write_data(f, settings.model_dump_json(indent=2))
+
+
+class StateStore(_LockedFileStore):
+    def __init__(self, path: Optional[str] = None):
+        if not path:
+            path = os.path.expanduser("~/.config/colab-cli/sessions.json")
+        super().__init__(path)
+
+    def _load_raw(self, f) -> Dict[str, SessionState]:
+        try:
+            f.seek(0)
+            content = f.read()
+            if not content or content.isspace():
+                return {}
+            data = json.loads(content)
+            return {k: SessionState(**v) for k, v in data.items()}
+        except Exception:
+            return {}
+
+    def _save_raw(self, f, sessions: Dict[str, SessionState]):
+        content = json.dumps({k: v.model_dump() for k, v in sessions.items()}, indent=2)
+        self._write_data(f, content)
+
+    def add(self, state: SessionState):
+        with self._lock_exclusive() as f:
+            sessions = self._load_raw(f)
+            sessions[state.name] = state
+            self._save_raw(f, sessions)
+
+    def get(self, name: str) -> Optional[SessionState]:
+        with self._lock_shared() as f:
+            if f is None:
+                return None
+            sessions = self._load_raw(f)
+            return sessions.get(name)
+
+    def remove(self, name: str):
+        with self._lock_exclusive() as f:
+            sessions = self._load_raw(f)
+            if name in sessions:
+                del sessions[name]
+                self._save_raw(f, sessions)
+
+    def list(self) -> Dict[str, SessionState]:
+        with self._lock_shared() as f:
+            if f is None:
+                return {}
+            return self._load_raw(f)

colab_cli/utils.py

@@ -0,0 +1,85 @@
+# Copyright 2026 Google LLC
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import base64
+import logging
+import sys
+import tempfile
+
+
+from typing import Optional
+
+
+def get_status_code(e: Exception) -> Optional[int]:
+    """Safely extracts status code from various exception types."""
+    if hasattr(e, "response") and e.response is not None:
+        if hasattr(e.response, "status_code"):
+            return e.response.status_code
+    if hasattr(e, "status_code"):
+        return e.status_code
+    return None
+
+
+def is_terminal_error(e: Exception) -> bool:
+    """Checks if an exception indicates a lost session (404/401)."""
+    code = get_status_code(e)
+    if code in (404, 401):
+        return True
+    # Some exceptions from jupyter-kernel-client might wrap the real one or be different
+    err_msg = str(e)
+    if "404" in err_msg or "401" in err_msg:
+        return True
+    return False
+
+
+def print_kitty(image_bytes: bytes):
+    """
+    Outputs an image using the Kitty Graphics Protocol.
+    Expects PNG bytes.
+
+    No-op when stdout is not a TTY: the escape sequence is meaningless to a
+    file/pipe and visually corrupts captured output (e.g. when piping
+    `colab exec` into a shell tool, redirecting to a log file, or running
+    under non-Kitty terminals). Callers still get the image via
+    `handle_image`'s file-write path.
+    """
+    if not sys.stdout.isatty():
+        return
+    try:
+        b64_data = base64.b64encode(image_bytes).decode("ascii")
+        sys.stdout.write("\n\033_Ga=T,f=100;")
+        sys.stdout.write(b64_data)
+        sys.stdout.write("\033\\\n")
+        sys.stdout.flush()
+    except Exception:
+        logging.exception("Kitty rendering failed")
+
+
+def handle_image(image_b64: str, mime_type: str = "image/png", target_path: str = None):
+    image_bytes = base64.b64decode(image_b64)
+    # Print inline using Kitty protocol
+    print_kitty(image_bytes)
+
+    if target_path:
+        # If a target path is specified, save it there
+        with open(target_path, "wb") as f:
+            f.write(image_bytes)
+        print(f"\n[Image saved to: {target_path}]")
+    else:
+        # Save to temp file as fallback
+        ext = mime_type.split("/")[-1]
+        tmp = tempfile.NamedTemporaryFile(delete=False, suffix=f".{ext}")
+        tmp.write(image_bytes)
+        tmp.close()
+        print(f"\n[Image saved to: {tmp.name}]")

google_colab_cli-0.5.4.dist-info/METADATA

@@ -0,0 +1,117 @@
+Metadata-Version: 2.4
+Name: google-colab-cli
+Version: 0.5.4
+Summary: CLI for interacting with Colab.
+License-File: LICENSE
+Requires-Python: >=3.13
+Requires-Dist: google-auth-oauthlib>=1.3.0
+Requires-Dist: google-auth>=2.49.1
+Requires-Dist: jupyter-kernel-client
+Requires-Dist: nbformat>=5.10.4
+Requires-Dist: packaging>=24.0
+Requires-Dist: prompt-toolkit>=3.0.52
+Requires-Dist: pydantic>=2.12.5
+Requires-Dist: pygments>=2.19.2
+Requires-Dist: pytest-cov>=7.0.0
+Requires-Dist: pytest-mock>=3.15.1
+Requires-Dist: pytest>=9.0.2
+Requires-Dist: requests>=2.32.5
+Requires-Dist: rich>=14.3.3
+Requires-Dist: typer>=0.24.1
+Description-Content-Type: text/markdown
+
+# Colab CLI
+
+A command-line interface for Google Colab. Create sessions, run code, manage files, and capture work — all without leaving your terminal.
+
+> Why? The agents are coming.
+
+## Install
+
+```bash
+uv tool install git+https://github.com/googlecolab/google-colab-cli
+```
+
+Note: If you have a non-standard default package index (Googlers), you may also need to add `--index https://pypi.org/simple`.
+
+
+## Quick start
+
+```bash
+colab new                              # provision a CPU session
+echo "print('hello')" | colab exec     # run code
+colab stop                             # release the VM
+```
+
+When only one session is active you can omit `-s <session>`; the CLI selects it automatically.
+
+## Commands
+
+### Sessions
+| Command | Description |
+| --- | --- |
+| `colab new [-s NAME] [--gpu T4\|L4\|A100\|H100] [--tpu v5e1\|v6e1]` | Provision a new session (CPU by default) |
+| `colab sessions` | List all active sessions on the backend |
+| `colab status [-s NAME]` | Show one session, or all locally-known sessions |
+| `colab stop -s NAME` | Terminate a session |
+| `colab url [-s NAME] [--open]` | Print a browser URL that opens the session in Colab |
+
+### Execution
+| Command | Description |
+| --- | --- |
+| `colab exec [-s NAME] [-f FILE] [--output-image PATH]` | Run Python from stdin, a `.py` file, or a `.ipynb` notebook |
+| `colab repl [-s NAME] [--output-image PATH]` | Interactive Python REPL (or one-shot if stdin is piped) |
+| `colab console [-s NAME]` | Raw TTY shell on the VM (or one-shot if stdin is piped) |
+
+### Files
+| Command | Description |
+| --- | --- |
+| `colab ls [-s NAME] [PATH]` | List remote files |
+| `colab upload -s NAME LOCAL REMOTE` | Upload a file |
+| `colab download -s NAME REMOTE LOCAL` | Download a file |
+| `colab rm -s NAME PATH` | Delete a remote file |
+| `colab edit -s NAME PATH` | Edit a remote file in `$EDITOR` |
+
+### Automation & utility
+| Command | Description |
+| --- | --- |
+| `colab auth -s NAME` | Authenticate the VM for GCP services |
+| `colab drivemount -s NAME [PATH]` | Mount Google Drive (default `/content/drive`) |
+| `colab install -s NAME [-r requirements.txt \| pkg ...]` | Install packages with `uv` (falls back to `pip`) |
+| `colab log [-s NAME] [-n N] [-o FILE]` | View or export session history (`.ipynb`/`.md`/`.txt`/`.jsonl`) |
+| `colab pay` | Open the Colab signup page |
+| `colab version` | Print the installed version |
+| `colab update [--install]` | Check for a newer release (and optionally install it) |
+| `colab help` | Show usage |
+
+### Global options
+- `--auth {oauth2,adc}` — authentication strategy (default `oauth2`)
+- `-c, --client-oauth-config PATH` — OAuth client config (default `~/.colab-cli-oauth-config.json`)
+- `--config PATH` — session state file (default `~/.config/colab-cli/sessions.json`)
+- `--logtostderr` — send all output to stderr
+
+## Examples
+
+```bash
+# Train a model on an A100, save the checkpoint locally
+colab new -s trainer --gpu A100
+colab install -s trainer torch transformers
+colab exec -s trainer -f train.py
+colab download -s trainer checkpoints/model.bin ./model.bin
+colab stop -s trainer
+
+# Mount Drive and analyze a notebook
+colab new -s analysis
+colab drivemount -s analysis
+colab exec -s analysis -f analysis.ipynb       # writes analysis_output.ipynb
+colab log -s analysis -o report.ipynb
+colab stop -s analysis
+```
+
+## Notes
+
+- `repl` and `console` require a TTY when run interactively. Pipe stdin to use them in scripts.
+- `exec` reads files locally and ships their contents to the VM — local edits don't require uploading.
+- Session metadata is stored at `~/.config/colab-cli/sessions.json`. Settings (auto-update etc.) live at `~/.config/colab-cli/settings.json`.
+
+See [`CONTRIBUTING.md`](./CONTRIBUTING.md) for how to file feedback.

google_colab_cli-0.5.4.dist-info/RECORD

@@ -0,0 +1,25 @@
+colab_cli/auth.py,sha256=OGhq_thOkZkEttSgEAeVnOjIEqVtwkSVB2HeZz6f01I,6586
+colab_cli/auto_update.py,sha256=JCQxgv8GwIlUPM36gQeZSk0pqhrJj7AVZ5fCZ2FP86k,7476
+colab_cli/cli.py,sha256=b4iCzBKiUtI-q6yJ4kOlvjFOb0XJ02gnBmqPdcjVZtY,4481
+colab_cli/client.py,sha256=mDIE4TgBgZAbCVCax_D9dp6CxeINk24QkhrMBIw50sE,10780
+colab_cli/common.py,sha256=J3xNCv43Xkgq4eQdBJtz15r41_BYzXPjdvob3fj3nw0,6368
+colab_cli/console.py,sha256=0snB6MQr-gEH7x_P87pPVyWBslSEJIZCtJuIx1S_LGA,5943
+colab_cli/contents.py,sha256=6vQspKs6zws88blwmJcniUjfVfYLCOW5lheNQG_Gs7Y,3026
+colab_cli/converter.py,sha256=IRFDy7o053DvEmyRBtCIMrgiH_Ol52j8-oUd2w1K3LI,7118
+colab_cli/history.py,sha256=0fHvipAZXdddzBz7LBqKYDJq-gC5M3D28aqwQeHrrbQ,2332
+colab_cli/repl.py,sha256=rZMU34opVw-gUy-F9oK2NQEs7hlPz8cu4vtbRjTdv-4,5697
+colab_cli/runtime.py,sha256=njZZ8zOnUkFvnGdVTIxZVOT552NPSG54H79uZQKG5v8,10734
+colab_cli/state.py,sha256=E6LueTijt6skatAbs8GLMdU68JDI5gFFvlXTwlailH0,4792
+colab_cli/utils.py,sha256=tuWWmM3GJdg3yUnv1lvvSLg6Pcox5jnjjYrqcIy3uBc,2865
+colab_cli/commands/__init__.py,sha256=A2GIGT_cfHV0jkPs0o9RPx0pHZP459CQoRn8o8KkR0E,575
+colab_cli/commands/automation.py,sha256=bmVq_x4EVtkkuWmp1tha-Ilag9OwX1XX9YLpZda0bRo,9290
+colab_cli/commands/execution.py,sha256=GbXmM_dYQayPIA9LSAiVrlRL8ivQulaoZfhjAcB070s,11222
+colab_cli/commands/files.py,sha256=VvguO3ftcPdl74HznvoKCmQw52257Fl64IqlWtFd7z4,6503
+colab_cli/commands/run.py,sha256=21fnKP5ceK6wXT6bM2w4au6esh7nIgWyIDismGVoS7c,15674
+colab_cli/commands/session.py,sha256=FycsSctSWlv-NpY9-_mI_zguE6j_SNEmVjL0edS2pvE,17016
+colab_cli/commands/utility.py,sha256=5HyicD91XEhpOBprt_9csNpocvNzNNHZZLezjNG2amI,13369
+google_colab_cli-0.5.4.dist-info/METADATA,sha256=2QwHjj4sjNlPW79buTBvRKwH8GW3rmaR-VvzxDXbgLI,4424
+google_colab_cli-0.5.4.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+google_colab_cli-0.5.4.dist-info/entry_points.txt,sha256=zepj_5XZElFi_sSsIf6_9i5JDbPFj71nFwvGFJU4mxc,45
+google_colab_cli-0.5.4.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+google_colab_cli-0.5.4.dist-info/RECORD,,

google_colab_cli-0.5.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

google_colab_cli-0.5.4.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+colab = colab_cli.cli:main