Raise default client timeout, add status_code property, fix integration tests

- Raise ScrapeDoClient default timeout from httpx's 5s to 60s to
  accommodate proxy round-trips (browser rendering, geo-routing,
  fingerprinting); update docstring accordingly
- Add ScrapeDoResponse.status_code property as a raw passthrough to the
  underlying httpx response, distinct from the envelope-aware
  target_status_code and scrape_do_status_code accessors
- Fix two integration tests that violated the 5000ms timeout floor in
  RequestParameters (2000 -> 5000); intent preserved against
  httpbingo.org/delay/10
- Update integration tests to use response.httpx_response.json() since
  the wrapper does not proxy json()
- Add unit tests for the new status_code property and the new default
  timeout

Author: svdC1

src/scrape_do/client.py

@@ -17,10 +17,7 @@
     BaseTransport,
     RequestError
     )
-from httpx._config import (
-    DEFAULT_TIMEOUT_CONFIG,
-    DEFAULT_LIMITS
-)
+from httpx._config import DEFAULT_LIMITS
 from httpx._types import (
     TimeoutTypes,
     CertTypes,
@@ -164,8 +161,10 @@ class ScrapeDoClient:
             authentication.
         http1 (bool): Enable HTTP/1.1 support.
         http2 (bool): Enable HTTP/2 multiplexing for higher concurrency.
-        timeout (TimeoutTypes): The default timeout configuration applied to
-            all network requests.
+        timeout (TimeoutTypes): The default timeout (in seconds) applied to
+            all network phases. Defaults to 60s, raised from httpx's 5s
+            default to accommodate Scrape.do proxy round-trips
+            (browser rendering, geo-routing, fingerprinting).
         limits (Limits): Configuration for maximum connection pool sizes.
         event_hooks (Optional[Mapping[str, list[Callable[..., Any]]]]): Custom
             hooks injected into the request/response lifecycle for logging or
@@ -186,7 +185,7 @@ def __init__(
         cert: Optional[CertTypes] = None,
         http1: bool = True,
         http2: bool = False,
-        timeout: TimeoutTypes = DEFAULT_TIMEOUT_CONFIG,
+        timeout: TimeoutTypes = 60.0,
         limits: Limits = DEFAULT_LIMITS,
         event_hooks: Optional[Mapping[str, list[Callable[..., Any]]]] = None,
         transport: Optional[BaseTransport] = None,

src/scrape_do/models/response.py

@@ -418,6 +418,19 @@ def httpx_response(self) -> httpx.Response:
         """
         return self._raw_response
 
+    @property
+    def status_code(self) -> int:
+        """Convenience accessor for the underlying HTTPX response status code.
+
+        Equivalent to `response.httpx_response.status_code`. Distinct from
+        `target_status_code` and `scrape_do_status_code`, which interpret the
+        Scrape.do response envelope.
+
+        Returns:
+            The HTTP status code of the response received from `api.scrape.do`.
+        """
+        return self.httpx_response.status_code
+
     @property
     def request(self) -> PreparedScrapeDoRequest:
         """Exposes the original, validated request configuration.

tests/integration/test_client.py

@@ -109,7 +109,7 @@ def test_proxy_timeout_logic(
         """
         response = no_retry_sync_client.get(
             f"{HTTPBIN_BASE}/delay/10",
-            timeout=2000
+            timeout=5000
             )
 
         # True proxy error
@@ -164,7 +164,7 @@ def test_transparent_proxy_timeout_logic(
         """
         response = no_retry_sync_client.get(
             f"{HTTPBIN_BASE}/delay/10",
-            timeout=2000,
+            timeout=5000,
             transparent_response=True
         )
 
@@ -201,7 +201,7 @@ def test_live_post_json_payload(
         assert response.status_code == 200
 
         # Parse the echo response
-        echoed_data = response.json()
+        echoed_data = response.httpx_response.json()
 
         # httpbin puts JSON payloads inside the 'json' key of its response
         assert echoed_data.get("json") == test_payload
@@ -246,7 +246,7 @@ def test_live_cookie_injection(
 
         assert response.status_code == 200
 
-        echoed_data = response.json()
+        echoed_data = response.httpx_response.json()
         returned_cookies = echoed_data.get("cookies", {})
 
         assert returned_cookies.get("session_token") == "secret_123"
@@ -274,7 +274,7 @@ def test_live_session_stickiness_and_ip_validation(
             session_id=888,
             super=True
             )
-        ip1 = resp1.json().get("origin")
+        ip1 = resp1.httpx_response.json().get("origin")
         rid1 = resp1.rid
 
         logger.info(f"Session 888 (Req 1) -> RID: {rid1} | IP: {ip1}")
@@ -285,7 +285,7 @@ def test_live_session_stickiness_and_ip_validation(
             session_id=888,
             super=True
             )
-        ip2 = resp2.json().get("origin")
+        ip2 = resp2.httpx_response.json().get("origin")
         rid2 = resp2.rid
 
         logger.info(f"Session 888 (Req 2) -> RID: {rid2} | IP: {ip2}")
@@ -312,7 +312,7 @@ def test_live_session_isolation(
             session_id=101,
             super=True
             )
-        ip_a = resp_a.json().get("origin")
+        ip_a = resp_a.httpx_response.json().get("origin")
         rid_a = resp_a.rid
 
         logger.info(f"Session 101 -> RID: {rid_a} | IP: {ip_a}")
@@ -322,7 +322,7 @@ def test_live_session_isolation(
             session_id=909,
             super=True
             )
-        ip_b = resp_b.json().get("origin")
+        ip_b = resp_b.httpx_response.json().get("origin")
         rid_b = resp_b.rid
 
         logger.info(f"Session 909 -> RID: {rid_b} | IP: {ip_b}")
@@ -355,7 +355,7 @@ def test_live_session_exhaustion_and_rotation(
             session_id=session_id,
             super=True
             )
-        initial_ip = resp_baseline.json().get("origin")
+        initial_ip = resp_baseline.httpx_response.json().get("origin")
         initial_rid = resp_baseline.rid
 
         logger.info(
@@ -376,7 +376,7 @@ def test_live_session_exhaustion_and_rotation(
                 session_id=session_id,
                 super=True
                 )
-            current_ip = resp_next.json().get("origin")
+            current_ip = resp_next.httpx_response.json().get("origin")
             current_rid = resp_next.rid
 
             logger.info((

tests/unit/models/test_response.py

@@ -287,6 +287,34 @@ def test_raise_for_status_success(make_request, make_response):
 
         resp = ScrapeDoResponse(req, resp).raise_for_status()
 
+    @staticmethod
+    def test_status_code_passthrough(example_url, mock_json_payload):
+        """
+        Ensures `status_code` is a raw passthrough to the underlying
+        httpx.Response status code, distinct from envelope-aware accessors
+        like `target_status_code`.
+        """
+        req = PreparedScrapeDoRequest(
+            api_params=RequestParameters(
+                url=example_url,
+                render=True,
+                return_json=True
+                )
+            )
+        # JSON mode pulls the target's reported status (envelope) and the
+        # proxy's gateway status (raw httpx) apart.
+        headers = {"scrape.do-initial-status-code": "200"}
+        http_resp = httpx.Response(
+            202, json=mock_json_payload, headers=headers
+            )
+        response = ScrapeDoResponse(request=req, response=http_resp)
+
+        # Raw outer status from api.scrape.do.
+        assert response.status_code == 202
+        # Envelope-aware: target reported 200 via JSON statusCode.
+        assert response.target_status_code == 200
+        assert response.scrape_do_status_code == 202
+
 
 class TestScrapeDoResponseSerialization:
 

tests/unit/test_client.py

@@ -76,6 +76,18 @@ def test_httpx_client_default_values(self, mock_env_vars):
             assert not transport._pool._http2
             assert transport._pool._max_connections == 50
 
+    def test_default_timeout_is_60_seconds(self, mock_env_vars):
+        """
+        Ensures the SDK's default timeout (60s across all phases) overrides
+        httpx's 5s default to comfortably accommodate proxy round-trips.
+        """
+        with ScrapeDoClient(api_token="test") as client:
+            timeout = client._http_client.timeout
+            assert timeout.connect == 60.0
+            assert timeout.read == 60.0
+            assert timeout.write == 60.0
+            assert timeout.pool == 60.0
+
     def test_explicit_close(self, mock_env_vars, mocker):
         """
         Ensures calling client.close() delegates to the httpx.Client