resolve

Author: Mantisus

CHANGELOG.md

@@ -2,6 +2,22 @@
 
 All notable changes to this project will be documented in this file.
 
+<!-- git-cliff-unreleased-start -->
+## 1.12.3 - **not yet released**
+
+### 🚀 Features
+
+- Extend status parameter to an array of possible statuses  ([#455](https://github.com/apify/apify-client-python/pull/455)) ([76f6769](https://github.com/apify/apify-client-python/commit/76f676973d067ce8af398d8e6ceea55595da5ecf)) by [@JanHranicky](https://github.com/JanHranicky)
+
+
+<!-- git-cliff-unreleased-end -->
+## [1.12.2](https://github.com/apify/apify-client-python/releases/tag/v1.12.2) (2025-08-08)
+
+### 🐛 Bug Fixes
+
+- Fix API error with stream ([#459](https://github.com/apify/apify-client-python/pull/459)) ([0c91ca5](https://github.com/apify/apify-client-python/commit/0c91ca516a01a6fca7bc8fa07f7bf9c15c75bf9d)) by [@Pijukatel](https://github.com/Pijukatel)
+
+
 ## [1.12.1](https://github.com/apify/apify-client-python/releases/tag/v1.12.1) (2025-07-30)
 
 ### 🐛 Bug Fixes
@@ -388,4 +404,4 @@ All notable changes to this project will be documented in this file.
 
 ## [0.0.1](https://github.com/apify/apify-client-python/releases/tag/v0.0.1) (2021-05-13)
 
-- Initial release of the package.
+- Initial release of the package.

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apify_client"
-version = "1.12.1"
+version = "1.12.3"
 description = "Apify API client for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "[email protected]" }]
 license = { file = "LICENSE" }
@@ -42,20 +42,22 @@ dependencies = [
 [dependency-groups]
 dev = [
     "dycw-pytest-only>=2.1.1",
-    "griffe~=1.9.0",
+    "griffe~=1.11.0",
     "mypy~=1.17.0",
-    "pre-commit~=4.2.0",
+    "pre-commit~=4.3.0",
     "pydoc-markdown~=4.8.0",
     "pytest-asyncio~=1.1.0",
     "pytest-cov~=6.2.0",
     "pytest-timeout>=2.4.0",
     "pytest-xdist~=3.8.0",
     "pytest~=8.4.0",
+    "pytest-httpserver>=1.1.3",
     "redbaron~=0.9.0",
     "respx~=0.22.0",
     "ruff~=0.12.0",
     "setuptools", # setuptools are used by pytest but not explicitly required
     "types-colorama~=0.4.15.20240106",
+    "werkzeug~=3.0.0", # Werkzeug is used by pytest-httpserver
 ]
 
 [tool.hatch.build.targets.wheel]

src/apify_client/_http_client.py

@@ -214,6 +214,9 @@ def _make_request(stop_retrying: Callable, attempt: int) -> httpx.Response:
             if response.status_code < 500 and response.status_code != HTTPStatus.TOO_MANY_REQUESTS:  # noqa: PLR2004
                 logger.debug('Status code is not retryable', extra={'status_code': response.status_code})
                 stop_retrying()
+
+            # Read the response in case it is a stream, so we can raise the error properly
+            response.read()
             raise ApifyApiError(response, attempt)
 
         return retry_with_exp_backoff(
@@ -304,6 +307,9 @@ async def _make_request(stop_retrying: Callable, attempt: int) -> httpx.Response
             if response.status_code < 500 and response.status_code != HTTPStatus.TOO_MANY_REQUESTS:  # noqa: PLR2004
                 logger.debug('Status code is not retryable', extra={'status_code': response.status_code})
                 stop_retrying()
+
+            # Read the response in case it is a stream, so we can raise the error properly
+            await response.aread()
             raise ApifyApiError(response, attempt)
 
         return await retry_with_exp_backoff_async(

src/apify_client/clients/resource_clients/run_collection.py

@@ -26,7 +26,7 @@ def list(
         limit: int | None = None,
         offset: int | None = None,
         desc: bool | None = None,
-        status: ActorJobStatus | None = None,
+        status: ActorJobStatus | list[ActorJobStatus] | None = None,
     ) -> ListPage[dict]:
         """List all Actor runs.
 
@@ -40,16 +40,21 @@ def list(
             limit: How many runs to retrieve.
             offset: What run to include as first when retrieving the list.
             desc: Whether to sort the runs in descending order based on their start date.
-            status: Retrieve only runs with the provided status.
+            status: Retrieve only runs with the provided statuses.
 
         Returns:
             The retrieved Actor runs.
         """
+        if isinstance(status, list):
+            status_param = [maybe_extract_enum_member_value(s) for s in status]
+        else:
+            status_param = maybe_extract_enum_member_value(status)
+
         return self._list(
             limit=limit,
             offset=offset,
             desc=desc,
-            status=maybe_extract_enum_member_value(status),
+            status=status_param,
         )
 
 
@@ -67,7 +72,7 @@ async def list(
         limit: int | None = None,
         offset: int | None = None,
         desc: bool | None = None,
-        status: ActorJobStatus | None = None,
+        status: ActorJobStatus | list[ActorJobStatus] | None = None,
     ) -> ListPage[dict]:
         """List all Actor runs.
 
@@ -81,14 +86,19 @@ async def list(
             limit: How many runs to retrieve.
             offset: What run to include as first when retrieving the list.
             desc: Whether to sort the runs in descending order based on their start date.
-            status: Retrieve only runs with the provided status.
+            status: Retrieve only runs with the provided statuses.
 
         Returns:
             The retrieved Actor runs.
         """
+        if isinstance(status, list):
+            status_param = [maybe_extract_enum_member_value(s) for s in status]
+        else:
+            status_param = maybe_extract_enum_member_value(status)
+
         return await self._list(
             limit=limit,
             offset=offset,
             desc=desc,
-            status=maybe_extract_enum_member_value(status),
+            status=status_param,
         )

tests/integration/__init__.py

@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import pytest
+
+if TYPE_CHECKING:
+    from apify_client import ApifyClient
+
+from apify_shared.consts import ActorJobStatus
+
+pytestmark = pytest.mark.integration
+
+
+class TestRunCollectionSync:
+    APIFY_HELLO_WORLD_ACTOR = 'apify/hello-world'
+    created_runs: list[dict]
+
+    def setup_runs(self, apify_client: ApifyClient) -> None:
+        self.created_runs = []
+
+        successfull_run = apify_client.actor(self.APIFY_HELLO_WORLD_ACTOR).call()
+        if successfull_run is not None:
+            self.created_runs.append(successfull_run)
+
+        timed_out_run = apify_client.actor(self.APIFY_HELLO_WORLD_ACTOR).call(timeout_secs=1)
+        if timed_out_run is not None:
+            self.created_runs.append(timed_out_run)
+
+    def teadown_runs(self, apify_client: ApifyClient) -> None:
+        for run in self.created_runs:
+            run_id = run.get('id')
+            if isinstance(run_id, str):
+                apify_client.run(run_id).delete()
+
+    async def test_run_collection_list_multiple_statuses(self, apify_client: ApifyClient) -> None:
+        self.setup_runs(apify_client)
+
+        run_collection = apify_client.actor(self.APIFY_HELLO_WORLD_ACTOR).runs()
+
+        multiple_status_runs = run_collection.list(status=[ActorJobStatus.SUCCEEDED, ActorJobStatus.TIMED_OUT])
+        single_status_runs = run_collection.list(status=ActorJobStatus.SUCCEEDED)
+
+        assert multiple_status_runs is not None
+        assert single_status_runs is not None
+
+        assert hasattr(multiple_status_runs, 'items')
+        assert hasattr(single_status_runs, 'items')
+
+        assert all(
+            run.get('status') in [ActorJobStatus.SUCCEEDED, ActorJobStatus.TIMED_OUT]
+            for run in multiple_status_runs.items
+        )
+        assert all(run.get('status') == ActorJobStatus.SUCCEEDED for run in single_status_runs.items)
+
+        self.teadown_runs(apify_client)

tests/integration/test_run_collection.py

@@ -0,0 +1,33 @@
+from collections.abc import Iterable, Iterator
+from logging import getLogger
+
+import pytest
+from pytest_httpserver import HTTPServer
+
+
+@pytest.fixture(scope='session')
+def make_httpserver() -> Iterable[HTTPServer]:
+    werkzeug_logger = getLogger('werkzeug')
+    werkzeug_logger.disabled = True
+
+    server = HTTPServer(threaded=True, host='127.0.0.1')
+    server.start()
+    yield server
+    server.clear()  # type: ignore[no-untyped-call]
+    if server.is_running():
+        server.stop()  # type: ignore[no-untyped-call]
+
+
+@pytest.fixture
+def httpserver(make_httpserver: HTTPServer) -> Iterable[HTTPServer]:
+    server = make_httpserver
+    yield server
+    server.clear()  # type: ignore[no-untyped-call]
+
+
+@pytest.fixture
+def patch_basic_url(httpserver: HTTPServer, monkeypatch: pytest.MonkeyPatch) -> Iterator[None]:
+    server_url = httpserver.url_for('/').removesuffix('/')
+    monkeypatch.setattr('apify_client.client.DEFAULT_API_URL', server_url)
+    yield
+    monkeypatch.undo()

tests/unit/__init__.py

@@ -1,50 +1,114 @@
+from __future__ import annotations
+
 import json
-from collections.abc import Generator
+import time
+from typing import TYPE_CHECKING
 
-import httpx
 import pytest
-import respx
+from werkzeug import Response
 
 from apify_client._errors import ApifyApiError
 from apify_client._http_client import HTTPClient, HTTPClientAsync
 
-_TEST_URL = 'http://example.com'
+if TYPE_CHECKING:
+    from collections.abc import Iterator
+
+    from pytest_httpserver import HTTPServer
+    from werkzeug import Request
+
+_TEST_PATH = '/errors'
 _EXPECTED_MESSAGE = 'some_message'
 _EXPECTED_TYPE = 'some_type'
 _EXPECTED_DATA = {
     'invalidItems': {'0': ["should have required property 'name'"], '1': ["should have required property 'name'"]}
 }
 
+RAW_ERROR = (
+    b'{\n'
+    b'  "error": {\n'
+    b'    "type": "insufficient-permissions",\n'
+    b'    "message": "Insufficient permissions for the Actor run. Make sure you\''
+    b're passing a correct API token and that it has the required permissions."\n'
+    b'  }\n'
+    b'}'
+)
+
+
+@pytest.fixture
+def test_endpoint(httpserver: HTTPServer) -> str:
+    httpserver.expect_request(_TEST_PATH).respond_with_json(
+        {'error': {'message': _EXPECTED_MESSAGE, 'type': _EXPECTED_TYPE, 'data': _EXPECTED_DATA}}, status=400
+    )
+    return str(httpserver.url_for(_TEST_PATH))
+
 
-@pytest.fixture(autouse=True)
-def mocked_response() -> Generator[respx.MockRouter]:
-    response_content = json.dumps(
-        {'error': {'message': _EXPECTED_MESSAGE, 'type': _EXPECTED_TYPE, 'data': _EXPECTED_DATA}}
+def streaming_handler(_request: Request) -> Response:
+    """Handler for streaming log requests."""
+
+    def generate_response() -> Iterator[bytes]:
+        for i in range(len(RAW_ERROR)):
+            yield RAW_ERROR[i : i + 1]
+            time.sleep(0.01)
+
+    return Response(
+        response=(RAW_ERROR[i : i + 1] for i in range(len(RAW_ERROR))),
+        status=403,
+        mimetype='application/octet-stream',
+        headers={'Content-Length': str(len(RAW_ERROR))},
     )
-    with respx.mock() as respx_mock:
-        respx_mock.get(_TEST_URL).mock(return_value=httpx.Response(400, content=response_content))
-        yield respx_mock
 
 
-def test_client_apify_api_error_with_data() -> None:
+def test_client_apify_api_error_with_data(test_endpoint: str) -> None:
     """Test that client correctly throws ApifyApiError with error data from response."""
     client = HTTPClient()
 
     with pytest.raises(ApifyApiError) as e:
-        client.call(method='GET', url=_TEST_URL)
+        client.call(method='GET', url=test_endpoint)
 
     assert e.value.message == _EXPECTED_MESSAGE
     assert e.value.type == _EXPECTED_TYPE
     assert e.value.data == _EXPECTED_DATA
 
 
-async def test_async_client_apify_api_error_with_data() -> None:
+async def test_async_client_apify_api_error_with_data(test_endpoint: str) -> None:
     """Test that async client correctly throws ApifyApiError with error data from response."""
     client = HTTPClientAsync()
 
     with pytest.raises(ApifyApiError) as e:
-        await client.call(method='GET', url=_TEST_URL)
+        await client.call(method='GET', url=test_endpoint)
 
     assert e.value.message == _EXPECTED_MESSAGE
     assert e.value.type == _EXPECTED_TYPE
     assert e.value.data == _EXPECTED_DATA
+
+
+def test_client_apify_api_error_streamed(httpserver: HTTPServer) -> None:
+    """Test that client correctly throws ApifyApiError when the response has stream."""
+
+    error = json.loads(RAW_ERROR.decode())
+
+    client = HTTPClient()
+
+    httpserver.expect_request('/stream_error').respond_with_handler(streaming_handler)
+
+    with pytest.raises(ApifyApiError) as e:
+        client.call(method='GET', url=httpserver.url_for('/stream_error'), stream=True, parse_response=False)
+
+    assert e.value.message == error['error']['message']
+    assert e.value.type == error['error']['type']
+
+
+async def test_async_client_apify_api_error_streamed(httpserver: HTTPServer) -> None:
+    """Test that async client correctly throws ApifyApiError when the response has stream."""
+
+    error = json.loads(RAW_ERROR.decode())
+
+    client = HTTPClientAsync()
+
+    httpserver.expect_request('/stream_error').respond_with_handler(streaming_handler)
+
+    with pytest.raises(ApifyApiError) as e:
+        await client.call(method='GET', url=httpserver.url_for('/stream_error'), stream=True, parse_response=False)
+
+    assert e.value.message == error['error']['message']
+    assert e.value.type == error['error']['type']