Fix CI: remove local vws-python dependency

Remove the [tool.uv.sources] section that pointed to a local
vws-python path which doesn't exist on CI runners.

Replace tests that depended on unreleased vws-python features
(request_timeout_seconds) with a test that uses tuple timeouts
directly with the requests library.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: adamtheturtle

pyproject.toml

@@ -480,6 +480,9 @@ ignore_names = [
     "REQUEST_QUOTA_REACHED",
     # pydantic-settings
     "model_config",
+    # TYPE_CHECKING imports used in string annotations
+    "HTTPAdapter",
+    "Callback",
 ]
 
 # Duplicate some of .gitignore
@@ -495,6 +498,3 @@ ignore_decorators = [
 [tool.yamlfix]
 section_whitelines = 1
 whitelines = 1
-
-[tool.uv.sources]
-vws-python = { path = "../vws-python", editable = true }

src/mock_vws/_requests_mock_server/decorators.py

@@ -4,7 +4,7 @@
 import threading
 import time
 from contextlib import ContextDecorator
-from typing import TYPE_CHECKING, Any, Literal, Self
+from typing import TYPE_CHECKING, Any, Literal, Self, cast
 from urllib.parse import urljoin, urlparse
 
 import requests as requests_lib
@@ -29,10 +29,10 @@
     from collections.abc import Callable, Iterable, Mapping
 
     from requests import PreparedRequest
-    from requests.adapters import HTTPAdapter  # noqa: F401
+    from requests.adapters import HTTPAdapter
 
     ResponseType = tuple[int, Mapping[str, str], str]
-    Callback = Callable[[PreparedRequest], ResponseType]  # noqa: F841
+    Callback = Callable[[PreparedRequest], ResponseType]
 
 # Thread-local storage to capture the request timeout
 _timeout_storage = threading.local()
@@ -157,10 +157,24 @@ def wrapped(request: "PreparedRequest") -> "ResponseType":
                 timeout = getattr(_timeout_storage, "timeout", None)
                 if timeout is not None and delay_seconds > 0:
                     # timeout can be a float or a tuple (connect, read)
+                    effective_timeout: float | None
+                    min_tuple_length_for_read_timeout = 2
                     if isinstance(timeout, tuple):
-                        effective_timeout: float | None = timeout[1]  # read timeout
+                        timeout_tuple = cast(
+                            tuple[float | None, float | None], timeout
+                        )
+                        if len(timeout_tuple) >= min_tuple_length_for_read_timeout:
+                            read_timeout_value = timeout_tuple[1]
+                            if isinstance(read_timeout_value, (int, float)):
+                                effective_timeout = float(read_timeout_value)
+                            else:
+                                effective_timeout = None
+                        else:
+                            effective_timeout = None
+                    elif isinstance(timeout, (int, float)):
+                        effective_timeout = float(timeout)
                     else:
-                        effective_timeout = timeout
+                        effective_timeout = None
                     if (
                         effective_timeout is not None
                         and delay_seconds > effective_timeout
@@ -175,18 +189,21 @@ def wrapped(request: "PreparedRequest") -> "ResponseType":
 
         mock = RequestsMock(assert_all_requests_are_fired=False)
 
-        # Patch _on_request to capture the timeout parameter
-        original_on_request = mock._on_request  # noqa: SLF001
+        # Patch _on_request to capture the timeout parameter.
+        # We cast to Any to bypass type checkers as we're intentionally
+        # accessing a private member of the responses library.
+        mock_any = cast(Any, mock)
+        original_on_request = mock_any._on_request  # noqa: SLF001
 
         def patched_on_request(
             adapter: "HTTPAdapter",
             request: "PreparedRequest",
             **kwargs: Any,  # noqa: ANN401
         ) -> Any:  # noqa: ANN401
             _timeout_storage.timeout = kwargs.get("timeout")
-            return original_on_request(adapter, request, **kwargs)  # type: ignore[misc]
+            return original_on_request(adapter, request, **kwargs)
 
-        mock._on_request = patched_on_request  # type: ignore[method-assign]  # noqa: SLF001
+        mock_any._on_request = patched_on_request  # noqa: SLF001
         for vws_route in self._mock_vws_api.routes:
             url_pattern = urljoin(
                 base=self._base_vws_url,

tests/mock_vws/test_requests_mock_usage.py

@@ -174,39 +174,26 @@ def test_delay_allows_completion() -> None:
             assert response.status_code is not None
 
     @staticmethod
-    def test_vws_client_with_timeout() -> None:
+    def test_delay_with_tuple_timeout() -> None:
         """
-        The VWS client's request_timeout_seconds parameter works with
-        response_delay_seconds.
+        The response delay works correctly with tuple timeouts
+        (connect_timeout, read_timeout).
         """
-        database = VuforiaDatabase()
-        with MockVWS(response_delay_seconds=0.5) as mock:
-            mock.add_database(database=database)
-            vws_client = VWS(
-                server_access_key=database.server_access_key,
-                server_secret_key=database.server_secret_key,
-                request_timeout_seconds=0.1,
+        with (
+            MockVWS(response_delay_seconds=0.5),
+            pytest.raises(expected_exception=requests.exceptions.Timeout),
+        ):
+            # Tuple timeout: (connect_timeout, read_timeout)
+            # The read timeout (0.1) is less than the delay (0.5)
+            requests.get(
+                url="https://vws.vuforia.com/summary",
+                headers={
+                    "Date": rfc_1123_date(),
+                    "Authorization": "bad_auth_token",
+                },
+                data=b"",
+                timeout=(5.0, 0.1),
             )
-            with pytest.raises(expected_exception=requests.exceptions.Timeout):
-                vws_client.list_targets()
-
-    @staticmethod
-    def test_vws_client_without_timeout() -> None:
-        """
-        The VWS client completes successfully when the timeout exceeds
-        the response delay.
-        """
-        database = VuforiaDatabase()
-        with MockVWS(response_delay_seconds=0.1) as mock:
-            mock.add_database(database=database)
-            vws_client = VWS(
-                server_access_key=database.server_access_key,
-                server_secret_key=database.server_secret_key,
-                request_timeout_seconds=2.0,
-            )
-            # This should succeed
-            targets = vws_client.list_targets()
-            assert targets == []
 
 
 class TestProcessingTime: