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

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

@@ -2,6 +2,15 @@
 
 All notable changes to this project will be documented in this file.
 
+## [3.2.1](https://github.com/apify/apify-client-python/releases/tag/v3.2.1) (2026-09-25)
+
+### 🐛 Bug Fixes
+
+- Stop dataset iterators from skipping items when unwind is used ([#1059](https://github.com/apify/apify-client-python/pull/1059)) ([8e30197](https://github.com/apify/apify-client-python/commit/8e301977ecb80b7c01251cacf071a3f6201469ba)) by [@vdusek](https://github.com/vdusek), closes [#1058](https://github.com/apify/apify-client-python/issues/1058)
+- Keep a failing background watcher from breaking a successful actor call ([#1027](https://github.com/apify/apify-client-python/pull/1027)) ([efc009d](https://github.com/apify/apify-client-python/commit/efc009d78f08d3a03a10db386201e48e45d01c2d)) by [@vdusek](https://github.com/vdusek)
+- Make `JsonSerializable` type alias read-only ([#1072](https://github.com/apify/apify-client-python/pull/1072)) ([bd82a26](https://github.com/apify/apify-client-python/commit/bd82a2645d3c64f0e4a30de3a016c16d92d48340)) by [@Pijukatel](https://github.com/Pijukatel)
+
+
 ## [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.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify_client
-Version: 3.2.0
+Version: 3.2.1
 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.1}/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.1}/pyproject.toml

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

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

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "apify_client"
-version = "3.2.0"
+version = "3.2.1"
 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.1}/src/apify_client/_pagination.py

@@ -19,9 +19,10 @@ The value of 1000 keeps backwards compatibility with the previous fixed cache si
 class HasItems(Protocol[T]):
     """Structural contract for a single page of results from a paginated API endpoint.
 
-    Implementations must expose `items`. They may optionally expose `count` - the number of items scanned by the API for
-    this page, which can exceed `len(items)` when filters drop items from the response. The iterator helpers consult
-    `count` opportunistically via `getattr` for offset bookkeeping and fall back to `len(items)` when it is absent.
+    Implementations must expose `items`. They may optionally expose `count` - the number of rows the API scanned to
+    produce this page, which `len(items)` can land below (filters drop items) or above (`unwind` splits one row into
+    several items). The iterator helpers consult `count` opportunistically via `getattr` for offset bookkeeping and
+    fall back to `len(items)` when it is absent.
     """
 
     items: list[T]
@@ -38,20 +39,19 @@ def get_items_iterator(
 
     The `callback` is invoked lazily to fetch each page from the API. It must accept `limit` and `offset` keyword
     arguments and return an object whose `items` attribute is a list. If the object also exposes a `count` attribute, it
-    is used for offset bookkeeping (the Apify API's `count` reflects items scanned, which can exceed items returned when
-    filters are applied).
+    is used for offset bookkeeping - `_page_scanned_rows` describes how the next offset is derived.
 
-    Iteration stops when a page scans no items (`count` is `0`, or `items` is empty when `count` is absent) or when the
-    user-requested `limit` is reached. A page can scan items while returning none - filters like `clean` drop items from
-    `items` but still count toward `count` - so terminating on scanned rather than returned items keeps the iterator
-    advancing across fully-filtered pages. The `total` field is intentionally not consulted, because it can change
-    between calls.
+    Iteration stops when a page scans no rows or when the user-requested `limit` is reached. A page can scan rows while
+    returning no items - filters like `clean` drop items from `items` but still count toward `count` - so terminating on
+    scanned rather than returned rows keeps the iterator advancing across fully-filtered pages. The `total` field is
+    intentionally not consulted, because it can change between calls.
 
     Args:
         callback: Function returning a single page of items.
-        limit: Maximum total number of items to yield across all pages. `None` or `0` means no limit.
+        limit: Maximum total number of rows scanned across all pages. On the dataset items endpoint `unwind` can
+            turn one row into several items, so more items than this can be yielded. `None` or `0` means no limit.
         offset: Starting offset for the first page.
-        chunk_size: Maximum number of items requested per API call. `None` or `0` lets the API decide.
+        chunk_size: Per-page cap, sent to the API as its `limit`. `None` or `0` lets the API decide.
     """
     effective_chunk = chunk_size or 0
     initial_offset = offset or 0
@@ -59,13 +59,14 @@ def get_items_iterator(
     fetched_items = 0
 
     while True:
+        page_limit = _next_page_limit(initial_limit, fetched_items, effective_chunk)
         current_page = callback(
-            limit=_next_page_limit(initial_limit, fetched_items, effective_chunk),
+            limit=page_limit,
             offset=initial_offset + fetched_items,
         )
         yield from current_page.items
 
-        page_scanned = max(getattr(current_page, 'count', 0), len(current_page.items))
+        page_scanned = _page_scanned_rows(current_page, page_limit)
         fetched_items += page_scanned
 
         if not page_scanned or (initial_limit and fetched_items >= initial_limit):
@@ -89,14 +90,15 @@ async def get_items_iterator_async(
     fetched_items = 0
 
     while True:
+        page_limit = _next_page_limit(initial_limit, fetched_items, effective_chunk)
         current_page = await callback(
-            limit=_next_page_limit(initial_limit, fetched_items, effective_chunk),
+            limit=page_limit,
             offset=initial_offset + fetched_items,
         )
         for item in current_page.items:
             yield item
 
-        page_scanned = max(getattr(current_page, 'count', 0), len(current_page.items))
+        page_scanned = _page_scanned_rows(current_page, page_limit)
         fetched_items += page_scanned
 
         if not page_scanned or (initial_limit and fetched_items >= initial_limit):
@@ -126,20 +128,30 @@ def get_cursor_iterator(
     limit: int | None = None,
     chunk_size: int | None = None,
 ) -> Iterator[KeyValueStoreKey] | Iterator[Request]:
-    """Yield individual items from cursor-paginated API responses.
+    """Yield individual items from a cursor-paginated API response.
+
+    This iterator supports the two API responses that use cursor pagination. `ListOfKeys` is used for key-value store
+    keys, while `ListOfRequests` is used for request queue requests.
+
+    Pagination continues until either:
+
+    - the API returns no next cursor, or
+    - the requested `limit` is reached.
+
+    An empty page does not explicitly stop the iteration. In practice, both supported endpoints return a next cursor
+    only when the current page contains items, so an empty page always has a `None` cursor and naturally ends the
+    iteration.
 
-    Cursor pagination is restricted to the two API responses that expose it: `ListOfKeys` (for key-value store keys) and
-    `ListOfRequests` (for request queue requests). Iteration ends when the next cursor is `None` or the user-requested
-    `limit` is reached. Emptiness alone does not stop iteration: server-side filters (such as the request-queue state
-    `filter`) can drop every item on a page while a live cursor still points at more data, so termination relies on the
-    cursor, not on whether a page returned items. Unlike offset responses, cursor responses expose no scanned-item
-    `count`, so `count` cannot be used to detect a fully-filtered page here.
+    The endpoints determine the next cursor differently:
+
+    - For key-value store keys, the cursor is the last key returned on the current page.
+    - For request queue requests, a cursor is returned only when the current page is full.
 
     Args:
-        callback: Function returning a single page of items. Receives `cursor` and `limit` kwargs.
-        cursor: Value of the cursor for the first request, or `None` to start from the beginning.
+        callback: Function that returns one page of items and accepts `cursor` and `limit` keyword arguments.
+        cursor: Cursor to use for the first request. If `None`, iteration starts from the beginning.
         limit: Maximum total number of items to yield across all pages.
-        chunk_size: Maximum number of items requested per API call.
+        chunk_size: Maximum number of items to request in a single API call.
     """
     effective_chunk = chunk_size or 0
     initial_limit = limit or 0
@@ -218,3 +230,19 @@ def _next_page_limit(initial_limit: int, fetched_items: int, effective_chunk: in
     if not effective_chunk:
         return remaining
     return min(remaining, effective_chunk)
+
+
+def _page_scanned_rows(page: HasItems[T], requested_limit: int) -> int:
+    """Compute how far the offset advances past `page`, in dataset rows.
+
+    Neither reported number is right on its own. `count` follows the rows the API scanned, but it is derived from a
+    dataset's item count, which is incremented by a throttled write and so lags a fresh push. `len(items)` counts the
+    items the API shaped out of those rows: filters (`clean`, `skip_empty`, `skip_hidden`) drop some, and `unwind`
+    splits one row into several. The larger of the two absorbs a `count` that lags behind the items returned, and
+    capping it at the rows the call asked for keeps an unwound page from advancing past rows the next call would then
+    never read. The cap is a valid bound because the endpoint applies the `limit` it is sent verbatim; on a page
+    covering fewer rows than that, the advance can still overshoot into rows a concurrent push appends afterwards. A
+    `requested_limit` of `0` means the call sent no limit, leaving the advance unbounded.
+    """
+    scanned_rows = max(getattr(page, 'count', 0), len(page.items))
+    return min(scanned_rows, requested_limit) if requested_limit else scanned_rows

{apify_client-3.2.0 → apify_client-3.2.1}/src/apify_client/_resource_clients/dataset.py

@@ -40,7 +40,7 @@ class DatasetItemsPage:
     """The offset of the first item in this page."""
 
     count: int
-    """Number of items in this page."""
+    """Number of dataset rows the API scanned for this page, or the number of items returned when that is larger."""
 
     limit: int
     """The limit that was used for this request."""
@@ -204,8 +204,8 @@ class DatasetClient(ResourceClient):
             items=items,
             total=int(response.headers['x-apify-pagination-total']),
             offset=int(response.headers['x-apify-pagination-offset']),
-            # x-apify-pagination-count returns count of processed items, not count of returned items
-            # This makes difference when items were filtered using hidden/empty
+            # The header counts the rows the API scanned, which `unwind` and a lagging dataset item count can
+            # both leave below the number of items returned.
             count=max(int(response.headers['x-apify-pagination-count']), len(items)),
             # API returns 999999999999 when no limit is used
             limit=int(response.headers['x-apify-pagination-limit']),
@@ -237,7 +237,8 @@ class DatasetClient(ResourceClient):
 
         Args:
             offset: Number of items that should be skipped at the start. The default value is 0.
-            limit: Maximum number of items to return. By default there is no limit.
+            limit: Maximum number of dataset rows to scan. Fewer items are yielded when filters drop some, more
+                when `unwind` splits a row into several. By default there is no limit.
             desc: By default, results are returned in the same order as they were stored. To reverse the order,
                 set this parameter to True.
             clean: If True, returns only non-empty items and skips hidden fields (i.e. fields starting with
@@ -260,7 +261,7 @@ class DatasetClient(ResourceClient):
             skip_hidden: If True, then hidden fields are skipped from the output, i.e. fields starting with
                 the # character.
             signature: Signature used to access the items.
-            chunk_size: Maximum number of items requested per API call when iterating across pages.
+            chunk_size: Maximum number of dataset rows requested per API call when iterating across pages.
             timeout: Timeout for the API HTTP request.
 
         Yields:
@@ -763,8 +764,8 @@ class DatasetClientAsync(ResourceClientAsync):
             items=items,
             total=int(response.headers['x-apify-pagination-total']),
             offset=int(response.headers['x-apify-pagination-offset']),
-            # x-apify-pagination-count returns count of processed items, not count of returned items
-            # This makes difference when items were filtered using hidden/empty
+            # The header counts the rows the API scanned, which `unwind` and a lagging dataset item count can
+            # both leave below the number of items returned.
             count=max(int(response.headers['x-apify-pagination-count']), len(items)),
             # API returns 999999999999 when no limit is used
             limit=int(response.headers['x-apify-pagination-limit']),
@@ -796,7 +797,8 @@ class DatasetClientAsync(ResourceClientAsync):
 
         Args:
             offset: Number of items that should be skipped at the start. The default value is 0.
-            limit: Maximum number of items to return. By default there is no limit.
+            limit: Maximum number of dataset rows to scan. Fewer items are yielded when filters drop some, more
+                when `unwind` splits a row into several. By default there is no limit.
             desc: By default, results are returned in the same order as they were stored. To reverse the order,
                 set this parameter to True.
             clean: If True, returns only non-empty items and skips hidden fields (i.e. fields starting with
@@ -819,7 +821,7 @@ class DatasetClientAsync(ResourceClientAsync):
             skip_hidden: If True, then hidden fields are skipped from the output, i.e. fields starting with
                 the # character.
             signature: Signature used to access the items.
-            chunk_size: Maximum number of items requested per API call when iterating across pages.
+            chunk_size: Maximum number of dataset rows requested per API call when iterating across pages.
             timeout: Timeout for the API HTTP request.
 
         Yields:

{apify_client-3.2.0 → apify_client-3.2.1}/src/apify_client/_status_message_watcher.py

@@ -120,11 +120,19 @@ class StatusMessageWatcherAsync(StatusMessageWatcherBase):
         await self.stop()
 
     async def _log_changed_status_message(self) -> None:
-        while True:
-            run_data = await self._run_client.get()
-            if not self._log_run_data(run_data):
-                break
-            await asyncio.sleep(self._check_period)
+        try:
+            while True:
+                run_data = await self._run_client.get()
+                if not self._log_run_data(run_data):
+                    break
+                await asyncio.sleep(self._check_period)
+        except Exception as exc:
+            if self._run_client._http_client.is_timeout_error(exc):  # noqa: SLF001
+                # An expected timeout, so warn rather than leak a traceback.
+                self._to_logger.warning('Status message redirection stopped: the status request timed out.')
+            else:
+                # A failed poll must not escape into `stop` and surface as a failure of the run.
+                self._to_logger.exception('Status message redirection stopped due to unexpected error:')
 
 
 @docs_group('Other')
@@ -159,10 +167,11 @@ class StatusMessageWatcher(StatusMessageWatcherBase):
 
         The caller is responsible for cleanup by calling the `stop` method when done.
         """
-        if self._logging_thread:
+        if self._logging_thread and self._logging_thread.is_alive():
             raise RuntimeError('Logging thread already active')
         self._stop_logging = False
-        self._logging_thread = threading.Thread(target=self._log_changed_status_message)
+        # A daemon thread, so a watcher still polling cannot hold up interpreter shutdown.
+        self._logging_thread = threading.Thread(target=self._log_changed_status_message, daemon=True)
         self._logging_thread.start()
         return self._logging_thread
 
@@ -189,9 +198,17 @@ class StatusMessageWatcher(StatusMessageWatcherBase):
         self.stop()
 
     def _log_changed_status_message(self) -> None:
-        while True:
-            if not self._log_run_data(self._run_client.get()):
-                break
-            if self._stop_logging:
-                break
-            time.sleep(self._check_period)
+        try:
+            while True:
+                if not self._log_run_data(self._run_client.get()):
+                    break
+                if self._stop_logging:
+                    break
+                time.sleep(self._check_period)
+        except Exception as exc:
+            if self._run_client._http_client.is_timeout_error(exc):  # noqa: SLF001
+                # An expected timeout, so warn rather than leak a traceback.
+                self._to_logger.warning('Status message redirection stopped: the status request timed out.')
+            else:
+                # A failed poll must not escape the background thread.
+                self._to_logger.exception('Status message redirection stopped due to unexpected error:')

{apify_client-3.2.0 → apify_client-3.2.1}/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
 
@@ -15,6 +15,7 @@ if TYPE_CHECKING:
     from types import TracebackType
 
     from apify_client._resource_clients import LogClient, LogClientAsync
+    from apify_client.http_clients import HttpResponse
     from apify_client.types import Timeout
 
 
@@ -79,10 +80,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
 
@@ -98,6 +99,13 @@ class StreamedLog(StreamedLogBase):
     call `start` and `stop` manually. Obtain an instance via `RunClient.get_streamed_log`.
     """
 
+    _stop_timeout_s: ClassVar[float] = 5
+    """Upper bound on how long `stop` waits for the streaming thread to finish.
+
+    Closing the response only ends the read on a transport that honours it, which neither Impit nor HTTPX does, so
+    without a bound `stop` would wait for the next chunk, which on a quiet run may be hours away.
+    """
+
     def __init__(self, log_client: LogClient, *, to_logger: logging.Logger, from_start: bool = True) -> None:
         """Initialize `StreamedLog`.
 
@@ -111,6 +119,7 @@ class StreamedLog(StreamedLogBase):
         super().__init__(to_logger=to_logger, from_start=from_start)
         self._log_client = log_client
         self._streaming_thread: Thread | None = None
+        self._log_stream: HttpResponse | None = None
         self._stop_logging = False
 
     def start(self) -> Thread:
@@ -118,7 +127,7 @@ class StreamedLog(StreamedLogBase):
 
         The caller is responsible for cleanup by calling the `stop` method when done.
         """
-        if self._streaming_thread:
+        if self._streaming_thread and self._streaming_thread.is_alive():
             raise RuntimeError('Streaming thread already active')
         self._stop_logging = False
         # A daemon thread so a stream still blocked on a read can never hold up interpreter shutdown.
@@ -127,13 +136,29 @@ class StreamedLog(StreamedLogBase):
         return self._streaming_thread
 
     def stop(self) -> None:
-        """Signal the streaming thread to stop logging and wait for it to finish."""
+        """Signal the streaming thread to stop logging and wait up to `_stop_timeout_s` for it to finish.
+
+        A thread that outlives the wait is a daemon with `_stop_logging` set, so it exits after at most one more chunk,
+        and only then does its buffered tail reach the logger. Its handle is kept while it is alive, so `start` cannot
+        revive it beside a second thread on the same buffer.
+        """
         if not self._streaming_thread:
             raise RuntimeError('Streaming thread is not active')
         self._stop_logging = True
-        self._streaming_thread.join()
-        self._streaming_thread = None
-        self._stop_logging = False
+        # Read once; the streaming thread clears the attribute as soon as the stream ends.
+        log_stream = self._log_stream
+        if log_stream is not None:
+            try:
+                log_stream.close()
+            except Exception:
+                # A failing `close` in a custom transport must not fail the caller.
+                self._to_logger.exception('Closing the log stream failed:')
+        self._streaming_thread.join(timeout=self._stop_timeout_s)
+        if self._streaming_thread.is_alive():
+            # Otherwise log messages arriving after `stop` returned have no explanation.
+            self._to_logger.debug('Log streaming thread outlived the stop timeout; it ends after the next chunk.')
+        else:
+            self._streaming_thread = None
 
     def __enter__(self) -> Self:
         """Start the streaming thread within the context. Exiting the context will finish the streaming thread."""
@@ -151,15 +176,30 @@ class StreamedLog(StreamedLogBase):
             with self._log_client.stream(raw=True, timeout=self._stream_timeout) as log_stream:
                 if not log_stream:
                     return
+                # Published so `stop` can close the response.
+                self._log_stream = log_stream
                 try:
+                    # `stop` may have run before the response existed for it to close.
+                    if self._stop_logging:
+                        return
                     for data in log_stream.iter_bytes():
                         self._process_new_data(data)
                         if self._stop_logging:
                             break
                 finally:
-                    # Flush the last buffered part even if the read timed out or was stopped.
-                    self._log_buffer_content(include_last_part=True)
+                    self._log_stream = None
+                    try:
+                        # Flush the last buffered part even if the read timed out or was stopped.
+                        self._log_buffer_content(include_last_part=True)
+                    except Exception:
+                        # A truncated stream leaves an undecodable tail, which is worth a traceback even while a stop
+                        # is in progress.
+                        self._to_logger.exception('Log redirection stopped due to unexpected error:')
         except Exception as exc:
+            if self._stop_logging:
+                # `stop` closed the stream out from under the read, so the failure is expected.
+                self._to_logger.debug('Log streaming stopped while `stop` was in progress: %r', exc)
+                return
             if self._log_client._http_client.is_timeout_error(exc):  # noqa: SLF001
                 # The stream cannot continue, so warn and let the thread end instead of leaking a traceback.
                 self._to_logger.warning('Log streaming stopped: the log stream request timed out.')
@@ -236,8 +276,13 @@ class StreamedLogAsync(StreamedLogBase):
                     async for data in log_stream.aiter_bytes():
                         self._process_new_data(data)
                 finally:
-                    # Flush the last buffered part even if the task is cancelled by `stop()`.
-                    self._log_buffer_content(include_last_part=True)
+                    try:
+                        # Flush the last buffered part even if the task is cancelled by `stop()`.
+                        self._log_buffer_content(include_last_part=True)
+                    except Exception:
+                        # A truncated stream leaves an undecodable tail. Keeping the failure here also keeps the
+                        # cancellation `stop` raised propagating, so the task ends up cancelled as asyncio expects.
+                        self._to_logger.exception('Log redirection stopped due to unexpected error:')
         except Exception as exc:
             if self._log_client._http_client.is_timeout_error(exc):  # noqa: SLF001
                 # A timeout on the long-lived stream is an expected terminal condition, not an error.

{apify_client-3.2.0 → apify_client-3.2.1}/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.1}/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)

{apify_client-3.2.0 → apify_client-3.2.1}/src/apify_client/types.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from collections.abc import Mapping, Sequence
 from datetime import timedelta
 from typing import Literal
 
@@ -38,7 +39,7 @@ to ad-hoc webhooks (e.g. `condition`) are ignored at runtime. The `*CamelDict` v
 matching the Apify API spelling.
 """
 
-JsonSerializable = dict[str, 'JsonSerializable'] | list['JsonSerializable'] | str | int | float | bool | None
+JsonSerializable = Mapping[str, 'JsonSerializable'] | Sequence['JsonSerializable'] | str | int | float | bool | None
 """Recursive type for JSON-serializable values - primitives plus objects and arrays with JSON-serializable contents.
 
 Based on the definition discussed in https://github.com/python/typing/issues/182.