apify-client 3.2.0__tar.gz → 3.2.1b1__tar.gz

{apify_client-3.2.0 → apify_client-3.2.1b1}/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 All notable changes to this project will be documented in this file.
 
+<!-- git-cliff-unreleased-start -->
+## 3.2.1 - **not yet released**
+
+
+<!-- git-cliff-unreleased-end -->
 ## [3.2.0](https://github.com/apify/apify-client-python/releases/tag/v3.2.0) (2026-09-03)
 
 ### 🚀 Features

{apify_client-3.2.0 → apify_client-3.2.1b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify_client
-Version: 3.2.0
+Version: 3.2.1b1
 Summary: Apify API client for Python
 Keywords: apify,api,client,automation,crawling,scraping
 Author: Apify Technologies s.r.o.
@@ -95,7 +95,7 @@ Description-Content-Type: text/markdown
     ```
 
     [Impit](https://github.com/apify/impit) is the default HTTP client and is installed automatically. To use the
-    built-in [HTTPX](https://github.com/pydantic/httpx2) client instead, install the optional `httpx2` extra, which
+    built-in [HTTPX2](https://github.com/pydantic/httpx2) client instead, install the optional `httpx2` extra, which
     provides Pydantic's maintained continuation of HTTPX, and pass `http_client=Httpx2HttpClient()` to
     `ApifyClient.with_custom_http_client()`:
 
@@ -172,7 +172,7 @@ For a guided walkthrough — authenticating, running an Actor, and reading its r
 - **Tiered timeouts** — short / medium / long tiers picked per endpoint, overridable per call ([Timeouts](https://docs.apify.com/api/client/python/docs/concepts/timeouts)).
 - **Pagination and streaming** — iterate datasets, key-value store keys, or live logs without manual paging or buffering ([Pagination](https://docs.apify.com/api/client/python/docs/concepts/pagination), [Streaming](https://docs.apify.com/api/client/python/docs/concepts/streaming-resources)).
 - **Convenience methods** — `call()`, `wait_for_finish()`, nested resource access, and other shortcuts that hide platform quirks ([Convenience methods](https://docs.apify.com/api/client/python/docs/concepts/convenience-methods)).
-- **Pluggable HTTP layer** — use the default [Impit](https://github.com/apify/impit)-based client, opt in to the built-in [HTTPX](https://github.com/pydantic/httpx2) client, or plug in any custom implementation ([HTTP clients](https://docs.apify.com/api/client/python/docs/concepts/custom-http-clients)).
+- **Pluggable HTTP layer** — use the default [Impit](https://github.com/apify/impit)-based client, opt in to the built-in [HTTPX2](https://github.com/pydantic/httpx2) client, or plug in any custom implementation ([HTTP clients](https://docs.apify.com/api/client/python/docs/concepts/custom-http-clients)).
 - **Structured errors** — every API error surfaces as an [`ApifyApiError`](https://docs.apify.com/api/client/python/reference/class/ApifyApiError) with HTTP-specific subclasses for precise handling ([Error handling](https://docs.apify.com/api/client/python/docs/concepts/error-handling)).
 - **Debug logging** — opt-in structured logging on the `apify_client` logger captures request URLs, status codes, retry attempts, and more ([Logging](https://docs.apify.com/api/client/python/docs/concepts/logging)).
 

{apify_client-3.2.0 → apify_client-3.2.1b1}/README.md

@@ -58,7 +58,7 @@
     ```
 
     [Impit](https://github.com/apify/impit) is the default HTTP client and is installed automatically. To use the
-    built-in [HTTPX](https://github.com/pydantic/httpx2) client instead, install the optional `httpx2` extra, which
+    built-in [HTTPX2](https://github.com/pydantic/httpx2) client instead, install the optional `httpx2` extra, which
     provides Pydantic's maintained continuation of HTTPX, and pass `http_client=Httpx2HttpClient()` to
     `ApifyClient.with_custom_http_client()`:
 
@@ -135,7 +135,7 @@ For a guided walkthrough — authenticating, running an Actor, and reading its r
 - **Tiered timeouts** — short / medium / long tiers picked per endpoint, overridable per call ([Timeouts](https://docs.apify.com/api/client/python/docs/concepts/timeouts)).
 - **Pagination and streaming** — iterate datasets, key-value store keys, or live logs without manual paging or buffering ([Pagination](https://docs.apify.com/api/client/python/docs/concepts/pagination), [Streaming](https://docs.apify.com/api/client/python/docs/concepts/streaming-resources)).
 - **Convenience methods** — `call()`, `wait_for_finish()`, nested resource access, and other shortcuts that hide platform quirks ([Convenience methods](https://docs.apify.com/api/client/python/docs/concepts/convenience-methods)).
-- **Pluggable HTTP layer** — use the default [Impit](https://github.com/apify/impit)-based client, opt in to the built-in [HTTPX](https://github.com/pydantic/httpx2) client, or plug in any custom implementation ([HTTP clients](https://docs.apify.com/api/client/python/docs/concepts/custom-http-clients)).
+- **Pluggable HTTP layer** — use the default [Impit](https://github.com/apify/impit)-based client, opt in to the built-in [HTTPX2](https://github.com/pydantic/httpx2) client, or plug in any custom implementation ([HTTP clients](https://docs.apify.com/api/client/python/docs/concepts/custom-http-clients)).
 - **Structured errors** — every API error surfaces as an [`ApifyApiError`](https://docs.apify.com/api/client/python/reference/class/ApifyApiError) with HTTP-specific subclasses for precise handling ([Error handling](https://docs.apify.com/api/client/python/docs/concepts/error-handling)).
 - **Debug logging** — opt-in structured logging on the `apify_client` logger captures request URLs, status codes, retry attempts, and more ([Logging](https://docs.apify.com/api/client/python/docs/concepts/logging)).
 

{apify_client-3.2.0 → apify_client-3.2.1b1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "apify_client"
-version = "3.2.0"
+version = "3.2.1b1"
 description = "Apify API client for Python"
 license = "Apache-2.0"
 license-files = ["LICENSE"]

{apify_client-3.2.0 → apify_client-3.2.1b1}/pyproject.toml.orig

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "apify_client"
-version = "3.2.0"
+version = "3.2.1b1"
 description = "Apify API client for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "support@apify.com" }]
 license = "Apache-2.0"

{apify_client-3.2.0 → apify_client-3.2.1b1}/src/apify_client/_streamed_log.py

@@ -7,7 +7,7 @@ import threading
 from asyncio import Task
 from datetime import UTC, datetime
 from threading import Thread
-from typing import TYPE_CHECKING, ClassVar, Self, cast
+from typing import TYPE_CHECKING, ClassVar, Self
 
 from apify_client._docs import docs_group
 
@@ -79,10 +79,10 @@ class StreamedLogBase:
         """Guess the log level from the message."""
         # Using only levels explicitly mentioned in the logging module
         known_levels = ('CRITICAL', 'FATAL', 'ERROR', 'WARN', 'WARNING', 'INFO', 'DEBUG', 'NOTSET')
+        level_names_to_levels = logging.getLevelNamesMapping()
         for level in known_levels:
             if level in message:
-                # `getLevelName` returns an `int` when string is passed as input.
-                return cast('int', logging.getLevelName(level))
+                return level_names_to_levels[level]
         # Unknown log level. Fall back to the default.
         return logging.INFO
 

{apify_client-3.2.0 → apify_client-3.2.1b1}/src/apify_client/http_clients/__init__.py

@@ -5,7 +5,7 @@ from apify_client.http_clients._impit import ImpitHttpClient, ImpitHttpClientAsy
 
 _install_import_hook(__name__)
 
-# `httpx2` is an optional extra, so the import is wrapped in try_import. Accessing the HTTPX clients without the
+# `httpx2` is an optional extra, so the import is wrapped in try_import. Accessing the HTTPX2 clients without the
 # extra installed raises a clear ImportError instead of failing at package import time.
 with _try_import(
     __name__,

{apify_client-3.2.0 → apify_client-3.2.1b1}/src/apify_client/http_clients/_httpx2.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-import httpx2 as httpx
+import httpx2
 from typing_extensions import override
 
 from apify_client._consts import (
@@ -24,32 +24,32 @@ if TYPE_CHECKING:
 
 
 _PERMANENT_ERRORS = (
-    # A request HTTPX rejects before sending it, e.g. one carrying an invalid header value.
-    httpx.LocalProtocolError,
-    # A URL scheme HTTPX refuses to speak, which repeating the request cannot change.
-    httpx.UnsupportedProtocol,
+    # A request HTTPX2 rejects before sending it, e.g. one carrying an invalid header value.
+    httpx2.LocalProtocolError,
+    # A URL scheme HTTPX2 refuses to speak, which repeating the request cannot change.
+    httpx2.UnsupportedProtocol,
     # An over-long redirect chain is a routing loop, which repeating the request cannot break.
-    httpx.TooManyRedirects,
+    httpx2.TooManyRedirects,
     # Only `Response.raise_for_status()` raises this, and the client never calls it - the shared pipeline decides on
     # status codes from the response itself.
-    httpx.HTTPStatusError,
+    httpx2.HTTPStatusError,
 )
-"""HTTPX errors that a retry cannot fix. Everything else in the `httpx.HTTPError` tree counts as transient."""
+"""HTTPX2 errors that a retry cannot fix. Everything else in the `httpx2.HTTPError` tree counts as transient."""
 
 
 @docs_group('HTTP clients')
 class Httpx2HttpClient(HttpClient):
-    """Synchronous HTTP client for the Apify API built on top of [HTTPX](https://github.com/pydantic/httpx2).
+    """Synchronous HTTP client for the Apify API built on top of [HTTPX2](https://github.com/pydantic/httpx2).
 
-    This client wraps `httpx.Client` and adds automatic retries with exponential backoff for rate-limited
+    This client wraps `httpx2.Client` and adds automatic retries with exponential backoff for rate-limited
     (HTTP 429) and server error (HTTP 5xx) responses.
 
-    HTTPX applies a request timeout to each socket operation rather than to the request as a whole, so a response
+    HTTPX2 applies a request timeout to each socket operation rather than to the request as a whole, so a response
     whose body arrives slowly keeps resetting it and can outlast both the requested timeout and `timeout_max`. The
     default Impit client enforces the same value as a deadline for the whole request, body included.
 
     Requires the `httpx2` extra: `pip install "apify-client[httpx2]"`. The `httpx2` package is Pydantic's maintained
-    continuation of HTTPX, which this module imports under the `httpx` name.
+    continuation of HTTPX.
     """
 
     def __init__(
@@ -66,7 +66,7 @@ class Httpx2HttpClient(HttpClient):
         headers: dict[str, str] | None = None,
         http_compressor: HttpCompressor | None = None,
     ) -> None:
-        """Initialize the HTTPX-based synchronous HTTP client.
+        """Initialize the HTTPX2-based synchronous HTTP client.
 
         Args:
             token: Apify API token for authentication.
@@ -93,27 +93,27 @@ class Httpx2HttpClient(HttpClient):
             http_compressor=http_compressor,
         )
 
-        self._httpx_client = httpx.Client(
+        self._httpx2_client = httpx2.Client(
             follow_redirects=True,
             event_hooks={'response': [self._clear_response_cookies]},
         )
 
     @override
     def is_timeout_error(self, exc: Exception) -> bool:
-        return super().is_timeout_error(exc) or isinstance(exc, httpx.TimeoutException)
+        return super().is_timeout_error(exc) or isinstance(exc, httpx2.TimeoutException)
 
     @override
     def is_retryable_transport_error(self, exc: Exception) -> bool:
-        # Every error from HTTPX's own hierarchy counts as transient except the permanently-failing types listed in
-        # `_PERMANENT_ERRORS`. Retrying is the default so a subclass HTTPX adds later is retried rather than
+        # Every error from HTTPX2's own hierarchy counts as transient except the permanently-failing types listed in
+        # `_PERMANENT_ERRORS`. Retrying is the default so a subclass HTTPX2 adds later is retried rather than
         # silently treated as fatal. HTTP status code errors are handled by the shared pipeline based on the
         # response status code, not here.
-        return isinstance(exc, httpx.HTTPError) and not isinstance(exc, _PERMANENT_ERRORS)
+        return isinstance(exc, httpx2.HTTPError) and not isinstance(exc, _PERMANENT_ERRORS)
 
     @override
     def close(self) -> None:
-        """Close the underlying HTTPX connection pool."""
-        self._httpx_client.close()
+        """Close the underlying HTTPX2 connection pool."""
+        self._httpx2_client.close()
 
     @override
     def send_request(
@@ -125,8 +125,8 @@ class Httpx2HttpClient(HttpClient):
         content: bytes | None,
         timeout: float | None,
         stream: bool,
-    ) -> httpx.Response:
-        request = self._httpx_client.build_request(
+    ) -> httpx2.Response:
+        request = self._httpx2_client.build_request(
             method=method,
             url=url,
             headers=headers,
@@ -134,26 +134,26 @@ class Httpx2HttpClient(HttpClient):
             timeout=timeout,
         )
         _restore_explicit_cookie_header(request, headers)
-        return self._httpx_client.send(request, stream=stream)
+        return self._httpx2_client.send(request, stream=stream)
 
-    def _clear_response_cookies(self, _response: httpx.Response) -> None:
-        """Prevent HTTPX's shared cookie jar from leaking server cookies into later API requests."""
-        self._httpx_client.cookies.clear()
+    def _clear_response_cookies(self, _response: httpx2.Response) -> None:
+        """Prevent HTTPX2's shared cookie jar from leaking server cookies into later API requests."""
+        self._httpx2_client.cookies.clear()
 
 
 @docs_group('HTTP clients')
 class Httpx2HttpClientAsync(HttpClientAsync):
-    """Asynchronous HTTP client for the Apify API built on top of [HTTPX](https://github.com/pydantic/httpx2).
+    """Asynchronous HTTP client for the Apify API built on top of [HTTPX2](https://github.com/pydantic/httpx2).
 
-    This client wraps `httpx.AsyncClient` and adds automatic retries with exponential backoff for rate-limited
+    This client wraps `httpx2.AsyncClient` and adds automatic retries with exponential backoff for rate-limited
     (HTTP 429) and server error (HTTP 5xx) responses.
 
-    HTTPX applies a request timeout to each socket operation rather than to the request as a whole, so a response
+    HTTPX2 applies a request timeout to each socket operation rather than to the request as a whole, so a response
     whose body arrives slowly keeps resetting it and can outlast both the requested timeout and `timeout_max`. The
     default Impit client enforces the same value as a deadline for the whole request, body included.
 
     Requires the `httpx2` extra: `pip install "apify-client[httpx2]"`. The `httpx2` package is Pydantic's maintained
-    continuation of HTTPX, which this module imports under the `httpx` name.
+    continuation of HTTPX.
     """
 
     def __init__(
@@ -170,7 +170,7 @@ class Httpx2HttpClientAsync(HttpClientAsync):
         headers: dict[str, str] | None = None,
         http_compressor: HttpCompressor | None = None,
     ) -> None:
-        """Initialize the HTTPX-based asynchronous HTTP client.
+        """Initialize the HTTPX2-based asynchronous HTTP client.
 
         Args:
             token: Apify API token for authentication.
@@ -197,27 +197,27 @@ class Httpx2HttpClientAsync(HttpClientAsync):
             http_compressor=http_compressor,
         )
 
-        self._httpx_async_client = httpx.AsyncClient(
+        self._httpx2_async_client = httpx2.AsyncClient(
             follow_redirects=True,
             event_hooks={'response': [self._clear_response_cookies]},
         )
 
     @override
     def is_timeout_error(self, exc: Exception) -> bool:
-        return super().is_timeout_error(exc) or isinstance(exc, httpx.TimeoutException)
+        return super().is_timeout_error(exc) or isinstance(exc, httpx2.TimeoutException)
 
     @override
     def is_retryable_transport_error(self, exc: Exception) -> bool:
-        # Every error from HTTPX's own hierarchy counts as transient except the permanently-failing types listed in
-        # `_PERMANENT_ERRORS`. Retrying is the default so a subclass HTTPX adds later is retried rather than
+        # Every error from HTTPX2's own hierarchy counts as transient except the permanently-failing types listed in
+        # `_PERMANENT_ERRORS`. Retrying is the default so a subclass HTTPX2 adds later is retried rather than
         # silently treated as fatal. HTTP status code errors are handled by the shared pipeline based on the
         # response status code, not here.
-        return isinstance(exc, httpx.HTTPError) and not isinstance(exc, _PERMANENT_ERRORS)
+        return isinstance(exc, httpx2.HTTPError) and not isinstance(exc, _PERMANENT_ERRORS)
 
     @override
     async def aclose(self) -> None:
-        """Close the underlying asynchronous HTTPX connection pool."""
-        await self._httpx_async_client.aclose()
+        """Close the underlying asynchronous HTTPX2 connection pool."""
+        await self._httpx2_async_client.aclose()
 
     @override
     async def send_request(
@@ -229,8 +229,8 @@ class Httpx2HttpClientAsync(HttpClientAsync):
         content: bytes | None,
         timeout: float | None,
         stream: bool,
-    ) -> httpx.Response:
-        request = self._httpx_async_client.build_request(
+    ) -> httpx2.Response:
+        request = self._httpx2_async_client.build_request(
             method=method,
             url=url,
             headers=headers,
@@ -238,17 +238,17 @@ class Httpx2HttpClientAsync(HttpClientAsync):
             timeout=timeout,
         )
         _restore_explicit_cookie_header(request, headers)
-        return await self._httpx_async_client.send(request, stream=stream)
+        return await self._httpx2_async_client.send(request, stream=stream)
 
-    async def _clear_response_cookies(self, _response: httpx.Response) -> None:
-        """Prevent HTTPX's shared cookie jar from leaking server cookies into later API requests."""
-        self._httpx_async_client.cookies.clear()
+    async def _clear_response_cookies(self, _response: httpx2.Response) -> None:
+        """Prevent HTTPX2's shared cookie jar from leaking server cookies into later API requests."""
+        self._httpx2_async_client.cookies.clear()
 
 
-def _restore_explicit_cookie_header(request: httpx.Request, headers: dict[str, str]) -> None:
-    """Keep only cookies explicitly supplied for this request, never cookies from HTTPX's shared jar.
+def _restore_explicit_cookie_header(request: httpx2.Request, headers: dict[str, str]) -> None:
+    """Keep only cookies explicitly supplied for this request, never cookies from HTTPX2's shared jar.
 
-    HTTPX drops the `Cookie` header when it builds a redirect request and rebuilds it from the jar, so an explicit
+    HTTPX2 drops the `Cookie` header when it builds a redirect request and rebuilds it from the jar, so an explicit
     cookie only reaches the first hop of a redirected request.
     """
     explicit_cookie = next((value for key, value in headers.items() if key.lower() == 'cookie'), None)