google-colab-cli 0.7.4__tar.gz → 0.7.5__tar.gz

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: google-colab-cli
-Version: 0.7.4
+Version: 0.7.5
 Summary: CLI for interacting with Colab.
 Project-URL: Homepage, https://github.com/googlecolab/google-colab-cli
 Project-URL: Repository, https://github.com/googlecolab/google-colab-cli
@@ -31,7 +31,7 @@ Requires-Dist: requests>=2.32.5
 Requires-Dist: rich>=14.3.3
 Requires-Dist: typer>=0.24.1
 Requires-Dist: typing-extensions>=4.0
-Requires-Dist: websocket-client>=1.0
+Requires-Dist: websocket-client>=1.6
 Description-Content-Type: text/markdown
 
 # Colab CLI
@@ -84,7 +84,7 @@ Run a CPU-based VM runtime, execute some code, and clean up:
 colab new
 
 # 2. Execute code from stdin
-echo "print('Hello from Google Colab!')" | colab exec
+echo 'print("Hello from Google Colab!")' | colab exec
 
 # 3. Stop and release the VM resource
 colab stop
@@ -226,3 +226,9 @@ To view interactive walkthroughs of eleven real-world automated scenarios, check
 ## Contributing
 
 Feedback and contributions are welcome! Please read [`CONTRIBUTING.md`](./CONTRIBUTING.md) for details.
+
+---
+
+## Legal & Privacy
+
+See Colab's [Terms of Service](https://research.google.com/colaboratory/tos_v6.html) and the [Google Privacy Policy](https://policies.google.com/privacy), which apply to usage of this CLI.

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/README.md

@@ -48,7 +48,7 @@ Run a CPU-based VM runtime, execute some code, and clean up:
 colab new
 
 # 2. Execute code from stdin
-echo "print('Hello from Google Colab!')" | colab exec
+echo 'print("Hello from Google Colab!")' | colab exec
 
 # 3. Stop and release the VM resource
 colab stop
@@ -190,3 +190,9 @@ To view interactive walkthroughs of eleven real-world automated scenarios, check
 ## Contributing
 
 Feedback and contributions are welcome! Please read [`CONTRIBUTING.md`](./CONTRIBUTING.md) for details.
+
+---
+
+## Legal & Privacy
+
+See Colab's [Terms of Service](https://research.google.com/colaboratory/tos_v6.html) and the [Google Privacy Policy](https://policies.google.com/privacy), which apply to usage of this CLI.

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/docs/01_session_management.md

@@ -1,5 +1,6 @@
 ---
 log:
+2026-10-14: Added configurable HTTP request timeouts and bounded allocation retries. Uncertain allocation POSTs are reconciled by GET using the same notebook hash before resubmission.
 2026-09-25: Runtime proxy tokens are now refreshed before expiry. `SessionState` persists `token_expires_at`, and `State.get_session` re-fetches the token via `GET /tun/m/assignments` when it's within 5 minutes of expiring.
 2026-09-25: Removed the keep-alive background daemon and related client/CLI ping functions. VM liveness is automatically maintained by the Colab backend based on kernel activity.
 2026-08-10: Added `colab usage` for account-level compute-unit rate/balance via `GET /tun/m/ccu-info` on the session backend (same bearer token as `colab new`).
@@ -53,6 +54,31 @@ The CLI maps user flags to these backend parameters:
 
 ## Approach
 
+### HTTP Timeout and Allocation Recovery
+
+`COLAB_CLI_REQUEST_TIMEOUT` sets the HTTP request timeout in seconds. If unset,
+the session's existing default applies (AuthorizedSession defaults to 120 seconds).
+An explicit `timeout=` passed by a caller takes precedence. This does not change
+kernel execution timeouts, Colab runtime lifetime, or benchmark job timeouts.
+
+Allocation POSTs retry `ReadTimeout` and HTTP 502/503/504 at most
+`COLAB_CLI_ASSIGN_RETRIES` times (default 3; 0 disables retries). Between attempts,
+the client waits `COLAB_CLI_RETRY_BACKOFF * 2**attempt` seconds (default 10, 20, 40).
+It then queries the same notebook hash: an existing allocation is returned directly;
+otherwise the refreshed XSRF token is used for the next POST. HTTP 412 still raises
+`TooManyAssignmentsError`; other errors are not retried. Failed initial/recovery
+GETs and exhausted POST retries propagate to the caller. There is no unlimited wait.
+
+```bash
+COLAB_CLI_REQUEST_TIMEOUT=300 COLAB_CLI_ASSIGN_RETRIES=3 COLAB_CLI_RETRY_BACKOFF=10 \
+  colab new --session kernel-benchmark-v6e --tpu v6e1
+```
+
+Regression tests cover timeout precedence, same-request recovery, refreshed
+tokens, retry limits, exponential backoff and permanent-error handling. A live
+allocation/recovery test is also required before declaring the behavior verified
+end to end; mocked timeouts alone do not establish backend compatibility.
+
 ### 1. New Session (`colab new`)
 - **API**: `GET https://colab.sandbox.google.com/tun/m/assign` (based on HAR).
 - **Parameters**:

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/pyproject.toml

@@ -38,7 +38,7 @@ dependencies = [
     "rich>=14.3.3",
     "typer>=0.24.1",
     "typing-extensions>=4.0",
-    "websocket-client>=1.0",
+    "websocket-client>=1.6",
 ]
 
 [project.scripts]

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/src/colab_cli/client.py

@@ -13,14 +13,19 @@
 # limitations under the License.
 
 import abc
+import json
+import logging
+import os
+import time
+import uuid
 from dataclasses import dataclass
 from datetime import datetime, timedelta, timezone
 from enum import Enum
-import json
-import logging
 from typing import Dict, List, Optional, Union
 from urllib.parse import urljoin, urlparse
-import uuid
+
+import requests
+from pydantic import BaseModel, Field, TypeAdapter
 
 from colab_cli.consumption import (
     CcuInfo,
@@ -28,8 +33,6 @@ from colab_cli.consumption import (
     consumption_user_info_from_tunnel,
 )
 from colab_cli.utils import get_status_code
-from pydantic import BaseModel, Field, TypeAdapter
-import requests
 
 # Standard Colab Headers
 ACCEPT_JSON_HEADER = {"key": "Accept", "value": "application/json"}
@@ -214,6 +217,12 @@ class Client:
             "value"
         ]
 
+        # Slow allocations may outlive AuthorizedSession's default read timeout.
+        if "timeout" not in kwargs:
+            timeout = os.getenv("COLAB_CLI_REQUEST_TIMEOUT")
+            if timeout:
+                kwargs["timeout"] = float(timeout)
+
         self.logger.debug(f"Request: {method} {endpoint}")
         self.logger.debug(f"Params: {params}")
 
@@ -269,20 +278,40 @@ class Client:
         accelerator: Optional[Accelerator] = None,
         shape: Optional[Shape] = None,
     ) -> Union[PostAssignmentResponse, Assignment]:
-        assignment = self._get_assignment(
-            notebook_hash, variant, accelerator, shape
-        )
+        assignment = self._get_assignment(notebook_hash, variant, accelerator, shape)
         if isinstance(assignment, Assignment):
             return assignment
 
-        try:
-            res = self._post_assignment(
-                notebook_hash, assignment.token, variant, accelerator, shape
-            )
-        except ColabRequestError as e:
-            if get_status_code(e) == 412:
-                raise TooManyAssignmentsError(str(e))
-            raise e
+        retries = max(0, int(os.getenv("COLAB_CLI_ASSIGN_RETRIES", "3")))
+        backoff = max(0.0, float(os.getenv("COLAB_CLI_RETRY_BACKOFF", "10")))
+        for attempt in range(retries + 1):
+            try:
+                res = self._post_assignment(
+                    notebook_hash, assignment.token, variant, accelerator, shape
+                )
+                break
+            except (ColabRequestError, requests.exceptions.ReadTimeout) as e:
+                status = (
+                    get_status_code(e) if isinstance(e, ColabRequestError) else None
+                )
+                if status == 412:
+                    raise TooManyAssignmentsError(str(e))
+                retryable = isinstance(
+                    e, requests.exceptions.ReadTimeout
+                ) or status in (502, 503, 504)
+                if not retryable or attempt >= retries:
+                    raise
+                delay = backoff * (2**attempt)
+                self.logger.warning(
+                    "Assignment request failed; retrying in %.0fs", delay
+                )
+                time.sleep(delay)
+                # Reconcile an uncertain POST before submitting the same request again.
+                assignment = self._get_assignment(
+                    notebook_hash, variant, accelerator, shape
+                )
+                if isinstance(assignment, Assignment):
+                    return assignment
 
         return res
 
@@ -329,4 +358,3 @@ class Client:
         return self._issue_request(
             url, method="POST", headers=headers, schema=PostAssignmentResponse
         )
-

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/src/colab_cli/commands/automation.py

@@ -102,8 +102,18 @@ def run_automation(
                 state.history.log_event(s.name, "drive_auth_needed", {"uri": uri})
                 sys.stdout.write("Press Enter after you have granted access... ")
                 sys.stdout.flush()
-                with open("/dev/tty") as tty:
-                    tty.readline()
+                try:
+                    with open("/dev/tty") as tty:
+                        tty.readline()
+                except (FileNotFoundError, OSError, IOError):
+                    # Windows has no /dev/tty; fall back to stdin.
+                    try:
+                        sys.stdin.readline()
+                    except Exception:
+                        try:
+                            input()
+                        except Exception:
+                            pass
 
             typer.echo("[colab] Authorizing VM...")
             params["dryrun"] = "false"

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/src/colab_cli/commands/ssh.py

@@ -37,7 +37,6 @@ the ``X-Colab-Ssh-Pubkey`` header. RSA keys are rejected by the server, so
 import contextlib
 import os
 from pathlib import Path
-import select
 import shlex
 import signal
 import subprocess
@@ -360,9 +359,6 @@ def _bridge_proxy_mode(ws: websocket.WebSocket) -> int:
     def stdin_to_ws():
         try:
             while True:
-                ready, _, _ = select.select([stdin_fd], [], [], None)
-                if not ready:
-                    continue
                 data = os.read(stdin_fd, 8192)
                 if not data:
                     break

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/src/colab_cli/console.py

@@ -17,10 +17,17 @@ import logging
 import os
 import signal
 import sys
-import termios
 import threading
 import time
-import tty
+
+try:
+    import termios
+    import tty
+except ImportError:
+    # Windows has neither termios nor tty. connect_console() below degrades
+    # gracefully to line-buffered input when these are unavailable.
+    termios = None  # type: ignore
+    tty = None  # type: ignore
 from urllib.parse import urlparse
 
 import websocket
@@ -133,8 +140,17 @@ def connect_console(session: SessionState):
     ws_url = f"{ws_scheme}://{parsed.netloc}/colab/tty?colab-runtime-proxy-token={session.token}"
 
     is_tty = sys.stdin.isatty()
-    fd = sys.stdin.fileno() if is_tty else None
-    old_settings = termios.tcgetattr(fd) if is_tty else None
+    fd = None
+    old_settings = None
+    can_raw = termios is not None and tty is not None and is_tty
+    if can_raw:
+        try:
+            fd = sys.stdin.fileno()
+            old_settings = termios.tcgetattr(fd)
+        except Exception:
+            fd = None
+            old_settings = None
+            can_raw = False
 
     ws = websocket.WebSocketApp(
         url=ws_url,
@@ -149,10 +165,12 @@ def connect_console(session: SessionState):
         if _is_running:
             send_terminal_size(ws)
 
+    sigwinch = getattr(signal, "SIGWINCH", None)
     try:
-        if is_tty:
+        if can_raw:
             tty.setraw(fd, termios.TCSANOW)
-            signal.signal(signal.SIGWINCH, handle_sigwinch)
+            if sigwinch is not None:
+                signal.signal(sigwinch, handle_sigwinch)
 
         # This is a blocking call until the connection is closed
         ws.run_forever()
@@ -164,9 +182,16 @@ def connect_console(session: SessionState):
                 # We raise a standard exception that the caller can recognize
                 raise RuntimeError(f"Connection failed: {err_msg}")
     finally:
-        if is_tty:
+        if can_raw:
             # Always ensure the terminal is restored to its original state
-            termios.tcsetattr(fd, termios.TCSANOW, old_settings)
+            try:
+                termios.tcsetattr(fd, termios.TCSANOW, old_settings)
+            except Exception:
+                pass
             # Restore the default signal handler for resize
-            signal.signal(signal.SIGWINCH, signal.SIG_DFL)
+            if sigwinch is not None:
+                try:
+                    signal.signal(sigwinch, signal.SIG_DFL)
+                except Exception:
+                    pass
         print("\r\nConnection closed.")

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/tests/test_client.py

@@ -12,16 +12,21 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import uuid
 import json
-import pytest
+import uuid
 from unittest.mock import MagicMock
+
+import pytest
+import requests
+
 from colab_cli.client import (
+    Accelerator,
+    Assignment,
     Client,
-    Prod,
+    ColabRequestError,
+    GetAssignmentResponse,
     PostAssignmentResponse,
-    Assignment,
-    Accelerator,
+    Prod,
     Shape,
     TooManyAssignmentsError,
     Variant,
@@ -39,6 +44,158 @@ def client(mock_session):
     return Client(Prod(), mock_session)
 
 
+def test_request_timeout_override_and_explicit_precedence(
+    client, mock_session, monkeypatch
+):
+    monkeypatch.setenv("COLAB_CLI_REQUEST_TIMEOUT", "300")
+    mock_session.request.return_value.text = ""
+    client._issue_request("https://colab.research.google.com/test")
+    assert mock_session.request.call_args.kwargs["timeout"] == 300
+    client._issue_request("https://colab.research.google.com/test", timeout=12)
+    assert mock_session.request.call_args.kwargs["timeout"] == 12
+
+
+def test_request_default_timeout_is_preserved(client, mock_session, monkeypatch):
+    monkeypatch.delenv("COLAB_CLI_REQUEST_TIMEOUT", raising=False)
+    mock_session.request.return_value.text = ""
+    client._issue_request("https://colab.research.google.com/test")
+    assert "timeout" not in mock_session.request.call_args.kwargs
+
+
+def pending_assignment(token="initial"):
+    return GetAssignmentResponse(acc="NONE", nbh="same", token=token, variant="DEFAULT")
+
+
+def allocated_assignment():
+    return Assignment(
+        endpoint="recovered",
+        runtimeProxyInfo={
+            "token": "proxy",
+            "tokenExpiresInSeconds": 3600,
+            "url": "http://backend",
+        },
+    )
+
+
+@pytest.mark.parametrize("status", [None, 502, 503, 504])
+def test_assign_recovers_before_another_post(client, mocker, monkeypatch, status):
+    monkeypatch.setenv("COLAB_CLI_ASSIGN_RETRIES", "3")
+    monkeypatch.setenv("COLAB_CLI_RETRY_BACKOFF", "10")
+    recovered = allocated_assignment()
+    get = mocker.patch.object(
+        client, "_get_assignment", side_effect=[pending_assignment(), recovered]
+    )
+    error = (
+        requests.exceptions.ReadTimeout("allocation pending")
+        if status is None
+        else ColabRequestError(
+            "transient", request=None, response=MagicMock(status_code=status)
+        )
+    )
+    post = mocker.patch.object(client, "_post_assignment", side_effect=error)
+    sleep = mocker.patch("time.sleep")
+    notebook = uuid.uuid4()
+    assert client.assign(notebook) is recovered
+    assert get.call_count == 2
+    assert all(call.args[0] == notebook for call in get.call_args_list)
+    post.assert_called_once()
+    sleep.assert_called_once_with(10)
+
+
+def test_assign_refreshes_token_and_uses_bounded_backoff(client, mocker, monkeypatch):
+    monkeypatch.setenv("COLAB_CLI_ASSIGN_RETRIES", "3")
+    monkeypatch.setenv("COLAB_CLI_RETRY_BACKOFF", "10")
+    mocker.patch.object(
+        client,
+        "_get_assignment",
+        side_effect=[pending_assignment(str(i)) for i in range(4)],
+    )
+    post = mocker.patch.object(
+        client,
+        "_post_assignment",
+        side_effect=requests.exceptions.ReadTimeout("pending"),
+    )
+    sleep = mocker.patch("time.sleep")
+    notebook = uuid.uuid4()
+    with pytest.raises(requests.exceptions.ReadTimeout):
+        client.assign(notebook)
+    assert [call.args[:2] for call in post.call_args_list] == [
+        (notebook, str(i)) for i in range(4)
+    ]
+    assert [call.args[0] for call in sleep.call_args_list] == [10, 20, 40]
+
+
+@pytest.mark.parametrize("status", [400, 401, 403])
+def test_assign_does_not_retry_nontransient_errors(client, mocker, status):
+    get = mocker.patch.object(
+        client, "_get_assignment", return_value=pending_assignment()
+    )
+    post = mocker.patch.object(
+        client,
+        "_post_assignment",
+        side_effect=ColabRequestError(
+            "permanent", request=None, response=MagicMock(status_code=status)
+        ),
+    )
+    sleep = mocker.patch("time.sleep")
+    with pytest.raises(ColabRequestError):
+        client.assign(uuid.uuid4())
+    get.assert_called_once()
+    post.assert_called_once()
+    sleep.assert_not_called()
+
+
+def test_assign_succeeds_after_recovery_refreshes_token(client, mocker, monkeypatch):
+    monkeypatch.setenv("COLAB_CLI_ASSIGN_RETRIES", "1")
+    monkeypatch.setenv("COLAB_CLI_RETRY_BACKOFF", "0")
+    get = mocker.patch.object(
+        client,
+        "_get_assignment",
+        side_effect=[pending_assignment("first"), pending_assignment("fresh")],
+    )
+    result = PostAssignmentResponse(
+        accelerator="NONE",
+        endpoint="new",
+        variant=0,
+        runtimeProxyInfo={
+            "token": "proxy",
+            "tokenExpiresInSeconds": 3600,
+            "url": "http://backend",
+        },
+    )
+    post = mocker.patch.object(
+        client,
+        "_post_assignment",
+        side_effect=[requests.exceptions.ReadTimeout("pending"), result],
+    )
+    mocker.patch("time.sleep")
+    notebook = uuid.uuid4()
+    assert client.assign(notebook) is result
+    assert get.call_count == 2
+    assert [call.args[:2] for call in post.call_args_list] == [
+        (notebook, "first"),
+        (notebook, "fresh"),
+    ]
+
+
+def test_assign_retries_can_be_disabled(client, mocker, monkeypatch):
+    monkeypatch.setenv("COLAB_CLI_ASSIGN_RETRIES", "0")
+    get = mocker.patch.object(
+        client, "_get_assignment", return_value=pending_assignment()
+    )
+    post = mocker.patch.object(
+        client,
+        "_post_assignment",
+        side_effect=requests.exceptions.ReadTimeout("pending"),
+    )
+    sleep = mocker.patch("time.sleep")
+    with pytest.raises(requests.exceptions.ReadTimeout):
+        client.assign(uuid.uuid4())
+    get.assert_called_once()
+    post.assert_called_once()
+    sleep.assert_not_called()
+
+
 def test_client_assign_new(client, mock_session):
     # Mock _get_assignment (GET)
     get_resp = MagicMock()

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/tests/test_console.py

@@ -15,13 +15,22 @@
 import json
 import os
 import sys
-import termios
 from unittest.mock import MagicMock, patch
 
+try:
+    import termios
+except ImportError:
+    # Windows has no termios; tests requiring raw-terminal mode are skipped.
+    termios = None  # type: ignore
+
 from colab_cli.console import connect_console, on_message, on_open
 from colab_cli.state import SessionState
 import pytest
 
+needs_termios = pytest.mark.skipif(
+    termios is None, reason="requires termios (POSIX only)"
+)
+
 
 @pytest.fixture
 def mock_session():
@@ -33,6 +42,7 @@ def mock_session():
     )
 
 
+@needs_termios
 @patch("colab_cli.console.websocket.WebSocketApp")
 @patch("colab_cli.console.tty.setraw")
 @patch("colab_cli.console.termios.tcgetattr")
@@ -79,6 +89,7 @@ def test_console_initialization(
     )
 
 
+@needs_termios
 @patch("colab_cli.console.websocket.WebSocketApp")
 @patch("colab_cli.console.tty.setraw")
 @patch("colab_cli.console.termios.tcgetattr")
@@ -220,3 +231,31 @@ def test_read_stdin_eof_tty_does_not_close_ws(
     sent_payloads = [json.loads(c.args[0]) for c in mock_ws.send.call_args_list]
     assert {"data": "exit\n"} not in sent_payloads
     mock_ws.close.assert_not_called()
+
+
+@patch("colab_cli.console.websocket.WebSocketApp")
+@patch("colab_cli.console.sys.stdin.isatty")
+def test_console_no_termios_degrades_gracefully(
+    mock_isatty, mock_ws_app, mock_session
+):
+    """Windows has no termios/tty/SIGWINCH. connect_console must not crash.
+
+    Regression test for `ModuleNotFoundError: No module named 'termios'`
+    which broke every `colab` command on Windows via
+    cli -> execution -> console imports.
+    """
+    import colab_cli.console as console_mod
+
+    mock_isatty.return_value = True
+    mock_ws_instance = MagicMock()
+    mock_ws_app.return_value = mock_ws_instance
+    mock_ws_instance.run_forever.return_value = None
+
+    with (
+        patch.object(console_mod, "termios", None),
+        patch.object(console_mod, "tty", None),
+        patch("colab_cli.console.threading.Thread"),
+    ):
+        connect_console(mock_session)
+
+    mock_ws_instance.run_forever.assert_called_once()

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/tests/test_ssh.py

@@ -25,6 +25,7 @@ import io
 import shlex
 import subprocess
 import sys
+import threading
 from unittest.mock import MagicMock
 
 from colab_cli.cli import app
@@ -235,6 +236,49 @@ def test_bridge_proxy_mode_pumps_ws_to_stdout(mocker):
     ws.close.assert_called()
 
 
+def test_bridge_proxy_mode_pumps_stdin_to_ws(mocker):
+    """os.read() chunks leave as binary frames; EOF ends the pump and closes
+    the socket.
+
+    Regression test: the pump used select() on the stdin fd before reading.
+    Windows select() only accepts sockets, so there the OSError killed the
+    pump thread and the remote side saw no input at all; a plain blocking
+    read works on every platform.
+    """
+    reads = iter([b"ping ", b"hello", b""])
+    stdin_eof = threading.Event()
+
+    def fake_read(fd, size):
+        chunk = next(reads)
+        if not chunk:
+            stdin_eof.set()
+        return chunk
+
+    mocker.patch("sys.stdin")
+    sys.stdin.buffer.fileno.return_value = 0
+    mocker.patch.object(ssh_module.os, "read", side_effect=fake_read)
+    fake_stdout = MagicMock()
+    fake_stdout.buffer = io.BytesIO()
+    mocker.patch("sys.stdout", fake_stdout)
+
+    # Hold the ws->stdout loop until the pump has drained stdin, so the
+    # send_binary assertions below can't race the reader thread.
+    def recv_data(control_frame):
+        stdin_eof.wait(timeout=5)
+        return (websocket.ABNF.OPCODE_CLOSE, b"")
+
+    ws = MagicMock()
+    ws.recv_data.side_effect = recv_data
+
+    rc = ssh_module._bridge_proxy_mode(ws)
+    assert rc == 0
+    assert [call.args[0] for call in ws.send_binary.call_args_list] == [
+        b"ping ",
+        b"hello",
+    ]
+    ws.close.assert_called()
+
+
 # --- ProxyCommand shell quoting ---------------------------------------------
 
 

{google_colab_cli-0.7.4 → google_colab_cli-0.7.5}/uv.lock

@@ -414,7 +414,7 @@ requires-dist = [
     { name = "rich", specifier = ">=14.3.3" },
     { name = "typer", specifier = ">=0.24.1" },
     { name = "typing-extensions", specifier = ">=4.0" },
-    { name = "websocket-client", specifier = ">=1.0" },
+    { name = "websocket-client", specifier = ">=1.6" },
 ]
 
 [package.metadata.requires-dev]
@@ -573,11 +573,11 @@ wheels = [
 
 [[package]]
 name = "oauthlib"
-version = "3.3.1"
+version = "4.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0b/5f/19930f824ffeb0ad4372da4812c50edbd1434f678c90c2733e1188edfc63/oauthlib-3.3.1.tar.gz", hash = "sha256:0f0f8aa759826a193cf66c12ea1af1637f87b9b4622d46e866952bb022e538c9", size = 185918, upload-time = "2025-06-19T22:48:08.269Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/7a/d8/a1bcc8ba112a627f8ffbdc212a78ce18d3ac07e91a5ca65d27918eee25a1/oauthlib-4.0.0.tar.gz", hash = "sha256:efb274799819440f95b4ab3b818869f1ce9ae26c5beacba0201d1a1b76b54f86", size = 187232, upload-time = "2026-09-28T06:01:18.77Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/be/9c/92789c596b8df838baa98fa71844d84283302f7604ed565dafe5a6b5041a/oauthlib-3.3.1-py3-none-any.whl", hash = "sha256:88119c938d2b8fb88561af5f6ee0eec8cc8d552b7bb1f712743136eb7523b7a1", size = 160065, upload-time = "2025-06-19T22:48:06.508Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/f4/78229a1066068ca14fc60fb26cf7381cabe4382261392b90e5f9552722d4/oauthlib-4.0.0-py3-none-any.whl", hash = "sha256:624c28c13a0a59cabf9747dfa52af63be3e512a7f2714df16e91b5b3a145e6cd", size = 159715, upload-time = "2026-09-28T06:01:17.008Z" },
 ]
 
 [[package]]
@@ -1160,11 +1160,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.7.0"
+version = "2.8.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/53/0c/06f8b233b8fd13b9e5ee11424ef85419ba0d8ba0b3138bf360be2ff56953/urllib3-2.7.0.tar.gz", hash = "sha256:231e0ec3b63ceb14667c67be60f2f2c40a518cb38b03af60abc813da26505f4c", size = 433602, upload-time = "2026-05-07T16:13:18.596Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e3/05/b17359e1cefb4f909b5e40b1b90a496d987258916dbbf88e842c729f510e/urllib3-2.8.0.tar.gz", hash = "sha256:63bf2ead4c879426ebf22ef2a781eeb4aa3b4ae798a0435506f8687fd5bb9b63", size = 458972, upload-time = "2026-09-15T19:29:36.253Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7f/3e/5db95bcf282c52709639744ca2a8b149baccf648e39c8cc87553df9eae0c/urllib3-2.7.0-py3-none-any.whl", hash = "sha256:9fb4c81ebbb1ce9531cce37674bbc6f1360472bc18ca9a553ede278ef7276897", size = 131087, upload-time = "2026-05-07T16:13:17.151Z" },
+    { url = "https://files.pythonhosted.org/packages/92/9d/c4e665119135114480843e7ab388fa94d8480650450e6f8e26b70d323a4c/urllib3-2.8.0-py3-none-any.whl", hash = "sha256:0cf3cae568d36aa9576b28dfb35f11328f1cb974ca7647d9475ebb86c75ac6e3", size = 135717, upload-time = "2026-09-15T19:29:34.577Z" },
 ]
 
 [[package]]