pyfunda 3.1.2__tar.gz → 3.1.4__tar.gz

{pyfunda-3.1.2 → pyfunda-3.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyfunda
-Version: 3.1.2
+Version: 3.1.4
 Summary: Python API wrapper for Funda.nl, the Dutch real estate platform. Reverse-engineered mobile API client, no scraping, no Selenium, no CAPTCHA.
 Project-URL: Homepage, https://github.com/0xMH/pyfunda
 Project-URL: Repository, https://github.com/0xMH/pyfunda

{pyfunda-3.1.2 → pyfunda-3.1.4}/funda/_transport.py

@@ -5,6 +5,7 @@ from collections.abc import Callable
 from dataclasses import dataclass, field
 from threading import Lock
 from typing import Any, ClassVar
+from urllib.parse import urlsplit
 
 from curl_cffi import requests
 import tls_client
@@ -20,22 +21,28 @@ from funda.models import Fingerprint, HttpMethod, JsonDict, RequestProfile
 class _FundaTransport:
     _cached_fingerprint_index: ClassVar[int | None] = None
     _fingerprint_cache_lock: ClassVar[Any] = Lock()
+    _request_pacing_lock: ClassVar[Any] = Lock()
+    _last_request_at: ClassVar[dict[str, float]] = {}
 
     timeout: int = 30
     max_retries: int = DEFAULT_MAX_RETRIES
-    retry_backoff: float = 0.1
+    retry_backoff: float = 0.5
+    min_request_interval: float = 0.5
     retry_statuses: set[int] | None = None
 
     _curl_session: requests.Session | None = field(default=None, init=False, repr=False)
     _tls_session: tls_client.Session | None = field(default=None, init=False, repr=False)
     _fingerprint: Fingerprint | None = field(default=None, init=False, repr=False)
     _fingerprint_index: int | None = field(default=None, init=False, repr=False)
+    _fingerprint_proven: bool = field(default=False, init=False, repr=False)
 
     def __post_init__(self) -> None:
         if self.max_retries < 0:
             raise ValueError("max_retries must be >= 0")
         if self.retry_backoff < 0:
             raise ValueError("retry_backoff must be >= 0")
+        if self.min_request_interval < 0:
+            raise ValueError("min_request_interval must be >= 0")
         if self.retry_statuses is None:
             self.retry_statuses = set(RETRY_STATUS_CODES)
         else:
@@ -62,25 +69,34 @@ class _FundaTransport:
     def _headers_dict(self, profile: RequestProfile = "listing") -> dict[str, str]:
         return dict(make_headers(profile))
 
-    def _select_fingerprint(self, start_index: int = 0) -> tuple[int, Fingerprint]:
-        if start_index == 0:
+    def _select_fingerprint(
+        self, start_index: int | None = None
+    ) -> tuple[int, Fingerprint, bool]:
+        if start_index is None:
             with type(self)._fingerprint_cache_lock:
                 cached_index = type(self)._cached_fingerprint_index
                 if cached_index is not None:
-                    return cached_index, FINGERPRINT_POOL[cached_index]
+                    return cached_index, FINGERPRINT_POOL[cached_index], True
+            start_index = 0
 
         index = start_index % len(FINGERPRINT_POOL)
-        return index, FINGERPRINT_POOL[index]
+        return index, FINGERPRINT_POOL[index], False
 
     def _remember_fingerprint(self) -> None:
         if self._fingerprint_index is None:
             return
+        self._fingerprint_proven = True
         with type(self)._fingerprint_cache_lock:
             type(self)._cached_fingerprint_index = self._fingerprint_index
 
-    def _ensure_session(self, fingerprint_start_index: int = 0) -> None:
+    def _ensure_session(self, fingerprint_start_index: int | None = None) -> None:
         if self._fingerprint is None:
-            self._fingerprint_index, self._fingerprint = self._select_fingerprint(fingerprint_start_index)
+            index, fingerprint, selected_proven = self._select_fingerprint(
+                fingerprint_start_index
+            )
+            self._fingerprint_index = index
+            self._fingerprint = fingerprint
+            self._fingerprint_proven = self._fingerprint_proven or selected_proven
 
         fingerprint = self._fingerprint
         if fingerprint.kind == "tls_ja3" and self._tls_session is None:
@@ -106,17 +122,21 @@ class _FundaTransport:
         self._curl_session = None
         self._tls_session = None
 
-    def _reset_transport(self, *, rotate: bool = False) -> int:
+    def _reset_transport(self, *, rotate: bool = False) -> int | None:
         current_index = self._fingerprint_index
         self._close_sessions()
         self._fingerprint = None
         self._fingerprint_index = None
-        if rotate and current_index is not None:
+        if current_index is None:
+            self._fingerprint_proven = False
+            return None
+        if rotate:
+            self._fingerprint_proven = False
             with type(self)._fingerprint_cache_lock:
                 if type(self)._cached_fingerprint_index == current_index:
                     type(self)._cached_fingerprint_index = None
             return (current_index + 1) % len(FINGERPRINT_POOL)
-        return 0
+        return current_index
 
     def get(self, url: str, *, profile: RequestProfile = "listing") -> Any:
         return self.request("GET", url, profile=profile)
@@ -140,7 +160,7 @@ class _FundaTransport:
         data: str | None = None,
         json_data: JsonDict | None = None,
     ) -> Any:
-        fingerprint_start_index = 0
+        fingerprint_start_index: int | None = None
 
         for attempt in range(self.max_retries + 1):
             try:
@@ -155,7 +175,9 @@ class _FundaTransport:
             except (requests.errors.RequestsError, TLSClientExeption):
                 if attempt >= self.max_retries:
                     raise
-                fingerprint_start_index = self._reset_transport(rotate=True)
+                fingerprint_start_index = self._reset_transport(
+                    rotate=not self._fingerprint_proven
+                )
                 self._sleep_backoff(attempt)
                 continue
 
@@ -163,19 +185,52 @@ class _FundaTransport:
                 self._remember_fingerprint()
                 return response
             if attempt >= self.max_retries:
+                detail = self._rejection_detail(response)
                 raise FundaRequestError(
                     f"Funda rejected {method} {url} after {attempt + 1} attempts "
-                    f"(status {response.status_code})"
+                    f"(status {response.status_code}){detail}"
                 )
 
-            fingerprint_start_index = self._reset_transport(rotate=True)
-            self._sleep_backoff(attempt)
+            rotate = response.status_code == 403 and not self._fingerprint_proven
+            fingerprint_start_index = self._reset_transport(rotate=rotate)
+            self._sleep_backoff(attempt, status_code=response.status_code)
 
         raise AssertionError("unreachable: retry loop must return or raise")
 
-    def _sleep_backoff(self, attempt: int) -> None:
-        if self.retry_backoff > 0:
-            time.sleep(self.retry_backoff * (attempt + 1))
+    def _sleep_backoff(self, attempt: int, *, status_code: int | None = None) -> None:
+        if self.retry_backoff <= 0:
+            return
+        multiplier = 2**attempt if status_code in (403, 429) else attempt + 1
+        time.sleep(self.retry_backoff * multiplier)
+
+    @staticmethod
+    def _rejection_detail(response: Any) -> str:
+        headers = getattr(response, "headers", {})
+        server = headers.get("server", headers.get("Server", ""))
+        text = getattr(response, "text", "")
+        if "AkamaiGHost" in server or "Access Denied" in text[:500]:
+            return (
+                ": Akamai denied the request; this is usually an IP-based rate or "
+                "reputation block, not a search payload error. Stop requests and retry "
+                "after a cooldown or from a different network"
+            )
+        return ""
+
+    def _pace_request(self, url: str) -> None:
+        if self.min_request_interval <= 0:
+            return
+
+        hostname = urlsplit(url).hostname or ""
+        pacing_key = "funda.io" if hostname.endswith(".funda.io") else hostname
+        with type(self)._request_pacing_lock:
+            now = time.monotonic()
+            last_request_at = type(self)._last_request_at.get(pacing_key)
+            if last_request_at is not None:
+                delay = self.min_request_interval - (now - last_request_at)
+                if delay > 0:
+                    time.sleep(delay)
+                    now = time.monotonic()
+            type(self)._last_request_at[pacing_key] = now
 
     def _send_once(
         self,
@@ -185,8 +240,9 @@ class _FundaTransport:
         profile: RequestProfile = "listing",
         data: str | None = None,
         json_data: JsonDict | None = None,
-        fingerprint_start_index: int = 0,
+        fingerprint_start_index: int | None = None,
     ) -> Any:
+        self._pace_request(url)
         self._ensure_session(fingerprint_start_index=fingerprint_start_index)
         fingerprint = self._fingerprint
         if fingerprint is None:

{pyfunda-3.1.2 → pyfunda-3.1.4}/funda/funda.py

@@ -64,8 +64,7 @@ class Funda:
     timeout: int = 30
     max_retries: int = DEFAULT_MAX_RETRIES
     retry_backoff: float = 0.5
-    min_request_interval: float = 0.0
-    adaptive_throttle: bool = True
+    min_request_interval: float = 0.5
 
     _transport: _FundaTransport = field(init=False, repr=False)
     _parallel_runner: _ParallelRunner["Funda"] | None = field(default=None, init=False, repr=False)
@@ -76,7 +75,6 @@ class Funda:
             max_retries=self.max_retries,
             retry_backoff=self.retry_backoff,
             min_request_interval=self.min_request_interval,
-            adaptive_throttle=self.adaptive_throttle,
         )
 
     def close(self) -> None:
@@ -508,7 +506,6 @@ class Funda:
             max_retries=self.max_retries,
             retry_backoff=self.retry_backoff,
             min_request_interval=self.min_request_interval,
-            adaptive_throttle=self.adaptive_throttle,
         )
 
     def _listing_id_from_input(self, listing_id: int | str) -> str:

{pyfunda-3.1.2 → pyfunda-3.1.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyfunda"
-version = "3.1.2"
+version = "3.1.4"
 description = "Python API wrapper for Funda.nl, the Dutch real estate platform. Reverse-engineered mobile API client, no scraping, no Selenium, no CAPTCHA."
 readme = "README.md"
 license = "AGPL-3.0-or-later"

pyfunda-3.1.4/tests/test_transport_parallel.py

@@ -0,0 +1,285 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from funda._parallel import _ParallelRunner
+from funda._transport import _FundaTransport
+from funda.constants import API_LISTING_TINY, FINGERPRINT_POOL
+from funda.exceptions import FundaRequestError
+from funda.headers import make_headers
+
+
+TEST_URL = API_LISTING_TINY.format(tiny_id=43117443)
+
+
+class FakeResponse:
+    def __init__(
+        self,
+        status_code: int,
+        *,
+        headers: dict[str, str] | None = None,
+        text: str = "",
+    ) -> None:
+        self.status_code = status_code
+        self.headers = headers or {}
+        self.text = text
+
+
+class RetryTransport(_FundaTransport):
+    def __init__(self, statuses: list[int], *, start_index: int = 0) -> None:
+        super().__init__(max_retries=len(statuses) - 1, retry_backoff=0)
+        self.statuses = statuses
+        self.starts: list[int] = []
+        self._fingerprint = FINGERPRINT_POOL[start_index]
+        self._fingerprint_index = start_index
+
+    def _send_once(self, *args, **kwargs):
+        if self._fingerprint is None:
+            index, fingerprint, selected_proven = self._select_fingerprint(
+                kwargs["fingerprint_start_index"]
+            )
+            self._fingerprint_index = index
+            self._fingerprint = fingerprint
+            self._fingerprint_proven = self._fingerprint_proven or selected_proven
+        self.starts.append(self._fingerprint_index)
+        return FakeResponse(self.statuses.pop(0))
+
+
+class TransportTests(unittest.TestCase):
+    def setUp(self) -> None:
+        for transport_type in (_FundaTransport, RetryTransport):
+            transport_type._cached_fingerprint_index = None
+            transport_type._last_request_at.clear()
+
+    def test_fingerprint_pool_entries_have_required_fields(self) -> None:
+        self.assertGreaterEqual(len(FINGERPRINT_POOL), 1)
+
+        for fingerprint in FINGERPRINT_POOL:
+            with self.subTest(fingerprint=fingerprint):
+                self.assertIn(
+                    fingerprint.kind,
+                    {"tls_ja3", "curl_ja3", "curl_impersonate", "tls_client"},
+                )
+                if fingerprint.kind in {"tls_ja3", "curl_ja3"}:
+                    self.assertTrue(fingerprint.ja3)
+                elif fingerprint.kind == "curl_impersonate":
+                    self.assertTrue(fingerprint.target)
+                elif fingerprint.kind == "tls_client":
+                    self.assertTrue(fingerprint.identifier)
+
+    def test_search_headers_are_convertible_for_tls_client(self) -> None:
+        header_list = make_headers("search")
+        header_dict = dict(header_list)
+
+        self.assertEqual(len(header_list), len(header_dict))
+        self.assertEqual(header_dict["referer"], "https://www.funda.nl/")
+        self.assertEqual(header_dict["accept"], "application/json")
+
+    def test_transport_validates_retry_settings(self) -> None:
+        with self.assertRaises(ValueError):
+            _FundaTransport(max_retries=-1)
+        with self.assertRaises(ValueError):
+            _FundaTransport(retry_backoff=-0.1)
+        with self.assertRaises(ValueError):
+            _FundaTransport(min_request_interval=-0.1)
+
+    def test_reset_transport_closes_sessions_and_rotates(self) -> None:
+        transport = _FundaTransport(retry_backoff=0)
+        curl_session = Mock()
+        tls_session = object()
+        transport._curl_session = curl_session
+        transport._tls_session = tls_session
+        transport._fingerprint = FINGERPRINT_POOL[0]
+        transport._fingerprint_index = 0
+
+        next_index = transport._reset_transport(rotate=True)
+
+        curl_session.close.assert_called_once()
+        self.assertIsNone(transport._curl_session)
+        self.assertIsNone(transport._tls_session)
+        self.assertIsNone(transport._fingerprint)
+        self.assertIsNone(transport._fingerprint_index)
+        self.assertFalse(transport._fingerprint_proven)
+        self.assertEqual(next_index, 1)
+
+    def test_reset_transport_preserves_proven_fingerprint_index(self) -> None:
+        transport = _FundaTransport(retry_backoff=0)
+        transport._fingerprint = FINGERPRINT_POOL[3]
+        transport._fingerprint_index = 3
+        transport._fingerprint_proven = True
+
+        next_index = transport._reset_transport(rotate=False)
+
+        self.assertEqual(next_index, 3)
+        self.assertTrue(transport._fingerprint_proven)
+
+    def test_request_rotates_unproven_fingerprint_after_403(self) -> None:
+        transport = RetryTransport([403, 200])
+        type(transport)._cached_fingerprint_index = None
+
+        response = transport.request("GET", TEST_URL)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(transport.starts, [0, 1])
+
+    def test_request_keeps_proven_fingerprint_after_403(self) -> None:
+        transport = RetryTransport([200, 403, 200], start_index=3)
+
+        first = transport.request("GET", TEST_URL)
+        second = transport.request("GET", TEST_URL)
+
+        self.assertEqual(first.status_code, 200)
+        self.assertEqual(second.status_code, 200)
+        self.assertEqual(transport.starts, [3, 3, 3])
+        self.assertEqual(type(transport)._cached_fingerprint_index, 3)
+
+    def test_proven_fingerprint_stays_sticky_if_global_preference_changes(self) -> None:
+        transport = RetryTransport([200, 403, 200], start_index=3)
+
+        transport.request("GET", TEST_URL)
+        type(transport)._cached_fingerprint_index = 4
+        response = transport.request("GET", TEST_URL)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(transport.starts, [3, 3, 3])
+
+    def test_proven_fingerprint_stays_sticky_for_retry_statuses(self) -> None:
+        for status in (403, 429, 503):
+            with self.subTest(status=status):
+                transport = RetryTransport([200, status, 200], start_index=3)
+
+                transport.request("GET", TEST_URL)
+                response = transport.request("GET", TEST_URL)
+
+                self.assertEqual(response.status_code, 200)
+                self.assertEqual(transport.starts, [3, 3, 3])
+
+    def test_rate_limit_does_not_rotate_unproven_fingerprint(self) -> None:
+        transport = RetryTransport([429, 200], start_index=3)
+
+        response = transport.request("GET", TEST_URL)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual(transport.starts, [3, 3])
+
+    def test_akamai_rejection_uses_exponential_backoff(self) -> None:
+        transport = RetryTransport([403, 403, 200])
+        transport.retry_backoff = 0.5
+
+        with patch("funda._transport.time.sleep") as sleep:
+            response = transport.request("GET", TEST_URL)
+
+        self.assertEqual(response.status_code, 200)
+        self.assertEqual([call.args[0] for call in sleep.call_args_list], [0.5, 1.0])
+
+    def test_request_raises_after_retry_statuses_are_exhausted(self) -> None:
+        with self.assertRaises(FundaRequestError):
+            RetryTransport([403, 403]).request("GET", TEST_URL)
+
+    def test_akamai_rejection_explains_ip_block(self) -> None:
+        transport = RetryTransport([403])
+
+        with patch.object(
+            transport,
+            "_send_once",
+            return_value=FakeResponse(
+                403,
+                headers={"Server": "AkamaiGHost"},
+                text="<title>Access Denied</title>",
+            ),
+        ), self.assertRaises(FundaRequestError) as ctx:
+            transport.request("POST", "https://listing-search-wonen.funda.io/_msearch/template")
+
+        self.assertIn("IP-based", str(ctx.exception))
+        self.assertIn("rate or reputation block", str(ctx.exception))
+        self.assertIn("retry after a cooldown", str(ctx.exception))
+
+    def test_rate_limit_statuses_use_exponential_backoff(self) -> None:
+        transport = _FundaTransport(retry_backoff=0.5)
+
+        with patch("funda._transport.time.sleep") as sleep:
+            for attempt in range(4):
+                transport._sleep_backoff(attempt, status_code=403)
+
+        self.assertEqual(
+            [call.args[0] for call in sleep.call_args_list],
+            [0.5, 1.0, 2.0, 4.0],
+        )
+
+    def test_pacing_can_be_disabled(self) -> None:
+        transport = _FundaTransport(min_request_interval=0)
+
+        with patch("funda._transport.time.monotonic") as monotonic, patch(
+            "funda._transport.time.sleep"
+        ) as sleep:
+            transport._pace_request("https://listing-search-wonen.funda.io/first")
+
+        monotonic.assert_not_called()
+        sleep.assert_not_called()
+
+    def test_pacing_is_shared_by_host_across_transports(self) -> None:
+        first = _FundaTransport(min_request_interval=0.5)
+        second = _FundaTransport(min_request_interval=0.5)
+        type(first)._last_request_at.clear()
+
+        with patch("funda._transport.time.monotonic", side_effect=[10.0, 10.1, 10.5]), patch(
+            "funda._transport.time.sleep"
+        ) as sleep:
+            first._pace_request("https://listing-search-wonen.funda.io/first")
+            second._pace_request("https://listing-detail-page.funda.io/second")
+
+        sleep.assert_called_once()
+        self.assertAlmostEqual(sleep.call_args.args[0], 0.4)
+        self.assertEqual(set(type(first)._last_request_at), {"funda.io"})
+
+    def test_client_defaults_to_half_second_pacing(self) -> None:
+        from funda import Funda
+
+        client = Funda()
+        try:
+            self.assertEqual(client.min_request_interval, 0.5)
+            self.assertEqual(client.retry_backoff, 0.5)
+        finally:
+            client.close()
+
+    def test_parallel_clients_preserve_request_interval(self) -> None:
+        from funda import Funda
+
+        client = Funda(min_request_interval=1.25)
+        parallel = client._parallel_client()
+        try:
+            self.assertEqual(parallel.min_request_interval, 1.25)
+            self.assertEqual(parallel._transport.min_request_interval, 1.25)
+        finally:
+            client.close()
+            parallel.close()
+
+
+class ParallelRunnerTests(unittest.TestCase):
+    def test_runner_reuses_thread_local_clients_and_preserves_order(self) -> None:
+        class Client:
+            created = 0
+            closed = 0
+
+            def __init__(self) -> None:
+                type(self).created += 1
+                self.id = type(self).created
+
+            def close(self) -> None:
+                type(self).closed += 1
+
+        runner = _ParallelRunner(Client, lambda client: client.close())
+        try:
+            first = runner.map(lambda client, item: (client.id, item * 2), range(8), workers=4)
+            second = runner.map(lambda client, item: (client.id, item * 3), range(8), workers=4)
+
+            self.assertEqual([value for _, value in first], [item * 2 for item in range(8)])
+            self.assertEqual([value for _, value in second], [item * 3 for item in range(8)])
+            self.assertLessEqual(Client.created, 4)
+        finally:
+            runner.close()
+
+        self.assertEqual(Client.closed, Client.created)
+
+
+if __name__ == "__main__":
+    unittest.main()

pyfunda-3.1.2/tests/test_transport_parallel.py

@@ -1,122 +0,0 @@
-import unittest
-from unittest.mock import Mock
-
-from funda._parallel import _ParallelRunner
-from funda._transport import _FundaTransport
-from funda.constants import API_LISTING_TINY, FINGERPRINT_POOL
-from funda.exceptions import FundaRequestError
-from funda.headers import make_headers
-
-
-TEST_URL = API_LISTING_TINY.format(tiny_id=43117443)
-
-
-class FakeResponse:
-    def __init__(self, status_code: int) -> None:
-        self.status_code = status_code
-
-
-class RetryTransport(_FundaTransport):
-    def __init__(self, statuses: list[int]) -> None:
-        super().__init__(max_retries=len(statuses) - 1, retry_backoff=0)
-        self.statuses = statuses
-        self.starts: list[int] = []
-        self._fingerprint = FINGERPRINT_POOL[0]
-        self._fingerprint_index = 0
-
-    def _send_once(self, *args, **kwargs):
-        self.starts.append(kwargs["fingerprint_start_index"])
-        return FakeResponse(self.statuses.pop(0))
-
-
-class TransportTests(unittest.TestCase):
-    def test_fingerprint_pool_entries_have_required_fields(self) -> None:
-        self.assertGreaterEqual(len(FINGERPRINT_POOL), 1)
-
-        for fingerprint in FINGERPRINT_POOL:
-            with self.subTest(fingerprint=fingerprint):
-                self.assertIn(
-                    fingerprint.kind,
-                    {"tls_ja3", "curl_ja3", "curl_impersonate", "tls_client"},
-                )
-                if fingerprint.kind in {"tls_ja3", "curl_ja3"}:
-                    self.assertTrue(fingerprint.ja3)
-                elif fingerprint.kind == "curl_impersonate":
-                    self.assertTrue(fingerprint.target)
-                elif fingerprint.kind == "tls_client":
-                    self.assertTrue(fingerprint.identifier)
-
-    def test_search_headers_are_convertible_for_tls_client(self) -> None:
-        header_list = make_headers("search")
-        header_dict = dict(header_list)
-
-        self.assertEqual(len(header_list), len(header_dict))
-        self.assertEqual(header_dict["referer"], "https://www.funda.nl/")
-        self.assertEqual(header_dict["accept"], "application/json")
-
-    def test_transport_validates_retry_settings(self) -> None:
-        with self.assertRaises(ValueError):
-            _FundaTransport(max_retries=-1)
-        with self.assertRaises(ValueError):
-            _FundaTransport(retry_backoff=-0.1)
-
-    def test_reset_transport_closes_sessions_and_rotates(self) -> None:
-        transport = _FundaTransport(retry_backoff=0)
-        curl_session = Mock()
-        tls_session = object()
-        transport._curl_session = curl_session
-        transport._tls_session = tls_session
-        transport._fingerprint = FINGERPRINT_POOL[0]
-        transport._fingerprint_index = 0
-
-        next_index = transport._reset_transport(rotate=True)
-
-        curl_session.close.assert_called_once()
-        self.assertIsNone(transport._curl_session)
-        self.assertIsNone(transport._tls_session)
-        self.assertIsNone(transport._fingerprint)
-        self.assertIsNone(transport._fingerprint_index)
-        self.assertEqual(next_index, 1)
-
-    def test_request_retries_retry_status_with_next_fingerprint(self) -> None:
-        transport = RetryTransport([403, 200])
-
-        response = transport.request("GET", TEST_URL)
-
-        self.assertEqual(response.status_code, 200)
-        self.assertEqual(transport.starts, [0, 1])
-
-    def test_request_raises_after_retry_statuses_are_exhausted(self) -> None:
-        with self.assertRaises(FundaRequestError):
-            RetryTransport([403, 403]).request("GET", TEST_URL)
-
-
-class ParallelRunnerTests(unittest.TestCase):
-    def test_runner_reuses_thread_local_clients_and_preserves_order(self) -> None:
-        class Client:
-            created = 0
-            closed = 0
-
-            def __init__(self) -> None:
-                type(self).created += 1
-                self.id = type(self).created
-
-            def close(self) -> None:
-                type(self).closed += 1
-
-        runner = _ParallelRunner(Client, lambda client: client.close())
-        try:
-            first = runner.map(lambda client, item: (client.id, item * 2), range(8), workers=4)
-            second = runner.map(lambda client, item: (client.id, item * 3), range(8), workers=4)
-
-            self.assertEqual([value for _, value in first], [item * 2 for item in range(8)])
-            self.assertEqual([value for _, value in second], [item * 3 for item in range(8)])
-            self.assertLessEqual(Client.created, 4)
-        finally:
-            runner.close()
-
-        self.assertEqual(Client.closed, Client.created)
-
-
-if __name__ == "__main__":
-    unittest.main()