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

@@ -495,6 +495,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

@@ -1,13 +1,12 @@
 """Decorators for using the mock."""
 
 import re
-import threading
 import time
 from contextlib import ContextDecorator
-from typing import TYPE_CHECKING, Any, Literal, Self
+from typing import TYPE_CHECKING, Literal, Self
 from urllib.parse import urljoin, urlparse
 
-import requests as requests_lib
+import requests
 from beartype import BeartypeConf, beartype
 from responses import RequestsMock
 
@@ -29,13 +28,9 @@
     from collections.abc import Callable, Iterable, Mapping
 
     from requests import PreparedRequest
-    from requests.adapters import HTTPAdapter  # noqa: F401
 
     ResponseType = tuple[int, Mapping[str, str], str]
-    Callback = Callable[[PreparedRequest], ResponseType]  # noqa: F841
-
-# Thread-local storage to capture the request timeout
-_timeout_storage = threading.local()
+    Callback = Callable[[PreparedRequest], ResponseType]
 
 _STRUCTURAL_SIMILARITY_MATCHER = StructuralSimilarityMatcher()
 _BRISQUE_TRACKING_RATER = BrisqueTargetTrackingRater()
@@ -152,20 +147,28 @@ def __enter__(self) -> Self:
         def wrap_callback(callback: "Callback") -> "Callback":
             """Wrap a callback to add a response delay."""
 
-            def wrapped(request: "PreparedRequest") -> "ResponseType":
-                # Check if the delay would exceed the request timeout
-                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)
-                    if isinstance(timeout, tuple):
-                        effective_timeout: float | None = timeout[1]  # read timeout
-                    else:
-                        effective_timeout = timeout
-                    if (
-                        effective_timeout is not None
-                        and delay_seconds > effective_timeout
-                    ):
-                        raise requests_lib.exceptions.Timeout
+            def wrapped(
+                request: "PreparedRequest",
+            ) -> "ResponseType":
+                # req_kwargs is added dynamically by the responses
+                # library onto PreparedRequest objects - it is not
+                # in the requests type stubs.
+                timeout = request.req_kwargs.get("timeout")  # type: ignore[attr-defined]
+                # requests allows timeout as a (connect, read)
+                # tuple. The delay simulates server response
+                # time, so compare against the read timeout.
+                effective: float | None = None
+                if isinstance(timeout, tuple):
+                    effective = timeout[1]
+                elif isinstance(timeout, (int, float)):
+                    effective = timeout
+
+                if (
+                    effective is not None
+                    and delay_seconds > effective
+                ):
+                    time.sleep(effective)
+                    raise requests.exceptions.Timeout
 
                 result = callback(request)
                 time.sleep(delay_seconds)
@@ -174,19 +177,6 @@ def wrapped(request: "PreparedRequest") -> "ResponseType":
             return wrapped
 
         mock = RequestsMock(assert_all_requests_are_fired=False)
-
-        # Patch _on_request to capture the timeout parameter
-        original_on_request = mock._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]
-
-        mock._on_request = patched_on_request  # type: ignore[method-assign]  # 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: