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,10 +1,9 @@
 """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, Any, Literal, Self, cast
 from urllib.parse import urljoin, urlparse
 
 import requests as requests_lib
@@ -26,16 +25,7 @@
 from .mock_web_services_api import MockVuforiaWebServicesAPI
 
 if TYPE_CHECKING:
-    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()
+    from collections.abc import Iterable
 
 _STRUCTURAL_SIMILARITY_MATCHER = StructuralSimilarityMatcher()
 _BRISQUE_TRACKING_RATER = BrisqueTargetTrackingRater()
@@ -149,44 +139,32 @@ def __enter__(self) -> Self:
         compiled_url_patterns: Iterable[re.Pattern[str]] = set()
         delay_seconds = self._response_delay_seconds
 
-        def wrap_callback(callback: "Callback") -> "Callback":
-            """Wrap a callback to add a response delay."""
+        mock = RequestsMock(assert_all_requests_are_fired=False)
+
+        if delay_seconds > 0:
+            mock_any = cast(Any, mock)
+            original_on_request = mock_any._on_request  # noqa: SLF001
 
-            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)
+            def patched_on_request(
+                *args: Any,  # noqa: ANN401
+                **kwargs: Any,  # noqa: ANN401
+            ) -> Any:  # noqa: ANN401
+                timeout = kwargs.get("timeout")
+                if timeout is not None:
                     if isinstance(timeout, tuple):
-                        effective_timeout: float | None = timeout[1]  # read timeout
+                        effective: float | None = timeout[1]
                     else:
-                        effective_timeout = timeout
+                        effective = timeout
                     if (
-                        effective_timeout is not None
-                        and delay_seconds > effective_timeout
+                        isinstance(effective, (int, float))
+                        and delay_seconds > effective
                     ):
                         raise requests_lib.exceptions.Timeout
-
-                result = callback(request)
+                result = original_on_request(*args, **kwargs)
                 time.sleep(delay_seconds)
                 return result
 
-            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
+            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,
@@ -205,7 +183,7 @@ def patched_on_request(
                 mock.add_callback(
                     method=vws_http_method,
                     url=compiled_url_pattern,
-                    callback=wrap_callback(callback=original_callback),
+                    callback=original_callback,
                     content_type=None,
                 )
 
@@ -227,7 +205,7 @@ def patched_on_request(
                 mock.add_callback(
                     method=vwq_http_method,
                     url=compiled_url_pattern,
-                    callback=wrap_callback(callback=original_callback),
+                    callback=original_callback,
                     content_type=None,
                 )
 

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: