apify 2.7.1b4__tar.gz → 2.7.1b5__tar.gz

{apify-2.7.1b4 → apify-2.7.1b5}/.github/workflows/pre_release.yaml

@@ -11,6 +11,10 @@ on:
   # Or it can be triggered manually.
   workflow_dispatch:
 
+concurrency:
+  group: release
+  cancel-in-progress: false
+
 jobs:
   release_metadata:
     if: "!startsWith(github.event.head_commit.message, 'docs') && !startsWith(github.event.head_commit.message, 'ci') && startsWith(github.repository, 'apify/')"

{apify-2.7.1b4 → apify-2.7.1b5}/.github/workflows/release.yaml

@@ -21,6 +21,10 @@ on:
         type: string
         default: ""
 
+concurrency:
+  group: release
+  cancel-in-progress: false
+
 jobs:
   release_metadata:
     name: Prepare release metadata

{apify-2.7.1b4 → apify-2.7.1b5}/.github/workflows/run_code_checks.yaml

@@ -6,12 +6,7 @@ on:
   # step required for PRs from forks. This prevents their potential exposure.
   pull_request:
 
-  # Pushing to the master branch triggers code checks
-  push:
-    branches:
-      - master
-    tags-ignore:
-      - "**" # Ignore all tags to prevent duplicate checks when tags are pushed.
+  # Trigger for pushing to the master branch is handled by the pre-release workflow.
 
   # It should also be possible to trigger checks manually
   workflow_dispatch:

{apify-2.7.1b4 → apify-2.7.1b5}/CHANGELOG.md

@@ -23,6 +23,13 @@ All notable changes to this project will be documented in this file.
 - Tagline overlap ([#501](https://github.com/apify/apify-sdk-python/pull/501)) ([bae8340](https://github.com/apify/apify-sdk-python/commit/bae8340c46fea756ea35ea4d591da84c09d478e2)) by [@katzino](https://github.com/katzino)
 
 
+## [2.7.2](https://github.com/apify/apify-sdk-python/releases/tag/v2.7.2) (2025-07-30)
+
+### 🐛 Bug Fixes
+
+- Restrict apify-shared and apify-client versions ([#523](https://github.com/apify/apify-sdk-python/pull/523)) ([581ebae](https://github.com/apify/apify-sdk-python/commit/581ebae5752a984a34cbabc02c49945ae392db00)) by [@vdusek](https://github.com/vdusek)
+
+
 ## [2.7.1](https://github.com/apify/apify-sdk-python/releases/tag/v2.7.1) (2025-07-24)
 
 ### 🐛 Bug Fixes

{apify-2.7.1b4 → apify-2.7.1b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify
-Version: 2.7.1b4
+Version: 2.7.1b5
 Summary: Apify SDK for Python
 Project-URL: Apify Homepage, https://apify.com
 Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog

{apify-2.7.1b4 → apify-2.7.1b5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apify"
-version = "2.7.1b4"
+version = "2.7.1b5"
 description = "Apify SDK for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "support@apify.com" }]
 license = { file = "LICENSE" }
@@ -62,7 +62,8 @@ scrapy = ["scrapy>=2.11.0"]
 
 [dependency-groups]
 dev = [
-    "build~=1.2.0",
+    "build~=1.3.0",
+    "crawlee[parsel]",
     "dycw-pytest-only>=2.1.1",
     "griffe~=1.9.0",
     "mypy~=1.17.0",
@@ -76,6 +77,7 @@ dev = [
     "respx~=0.22.0",
     "ruff~=0.12.0",
     "setuptools", # setuptools are used by pytest but not explicitly required
+    "uvicorn[standard]",
 ]
 
 [tool.hatch.build.targets.wheel]

{apify-2.7.1b4 → apify-2.7.1b5}/tests/integration/actor_source_base/Dockerfile

@@ -12,4 +12,4 @@ RUN echo "Python version:" \
  && echo "All installed Python packages:" \
  && pip freeze
 
-CMD ["python3", "-m", "src"]
+CMD ["sh", "-c", "python server.py & python -m src"]

{apify-2.7.1b4 → apify-2.7.1b5}/tests/integration/actor_source_base/requirements.txt

@@ -1,2 +1,4 @@
 # The test fixture will put the Apify SDK wheel path on the next line
 APIFY_SDK_WHEEL_PLACEHOLDER
+uvicorn[standard]
+crawlee[parsel]

apify-2.7.1b5/tests/integration/actor_source_base/server.py

@@ -0,0 +1,101 @@
+"""
+Test server is infinite server http://localhost:8080/{any_number} and each page has links to the next 10 pages.
+For example:
+    http://localhost:8080/ contains links:
+http://localhost:8080/0, http://localhost:8080/1, ..., http://localhost:8080/9
+
+    http://localhost:8080/1 contains links:
+http://localhost:8080/10, http://localhost:8080/11, ..., http://localhost:8080/19
+
+... and so on.
+"""
+
+import asyncio
+import logging
+from collections.abc import Awaitable, Callable, Coroutine
+from socket import socket
+from typing import Any
+
+from uvicorn import Config
+from uvicorn.server import Server
+from yarl import URL
+
+Receive = Callable[[], Awaitable[dict[str, Any]]]
+Send = Callable[[dict[str, Any]], Coroutine[None, None, None]]
+
+
+async def send_html_response(send: Send, html_content: bytes, status: int = 200) -> None:
+    """Send an HTML response to the client."""
+    await send(
+        {
+            'type': 'http.response.start',
+            'status': status,
+            'headers': [[b'content-type', b'text/html; charset=utf-8']],
+        }
+    )
+    await send({'type': 'http.response.body', 'body': html_content})
+
+
+async def app(scope: dict[str, Any], _: Receive, send: Send) -> None:
+    """Main ASGI application handler that routes requests to specific handlers.
+
+    Args:
+        scope: The ASGI connection scope.
+        _: The ASGI receive function.
+        send: The ASGI send function.
+    """
+    assert scope['type'] == 'http'
+    path = scope['path']
+
+    links = '\n'.join(f'<a href="{path}{i}">{path}{i}</a>' for i in range(10))
+    await send_html_response(
+        send,
+        f"""\
+<html><head>
+    <title>Title for {path} </title>
+</head>
+<body>
+    {links}
+</body></html>""".encode(),
+    )
+
+
+class TestServer(Server):
+    """A test HTTP server implementation based on Uvicorn Server."""
+
+    @property
+    def url(self) -> URL:
+        """Get the base URL of the server.
+
+        Returns:
+            A URL instance with the server's base URL.
+        """
+        protocol = 'https' if self.config.is_ssl else 'http'
+        return URL(f'{protocol}://{self.config.host}:{self.config.port}/')
+
+    async def serve(self, sockets: list[socket] | None = None) -> None:
+        """Run the server."""
+        if sockets:
+            raise RuntimeError('Simple TestServer does not support custom sockets')
+        self.restart_requested = asyncio.Event()
+
+        loop = asyncio.get_event_loop()
+        tasks = {
+            loop.create_task(super().serve()),
+        }
+        await asyncio.wait(tasks)
+
+
+if __name__ == '__main__':
+    asyncio.run(
+        TestServer(
+            config=Config(
+                app=app,
+                lifespan='off',
+                loop='asyncio',
+                port=8080,
+                log_config=None,
+                log_level=logging.CRITICAL,
+            )
+        ).serve()
+    )

{apify-2.7.1b4 → apify-2.7.1b5}/tests/integration/test_actor_api_helpers.py

@@ -400,12 +400,12 @@ async def test_actor_adds_webhook_and_receives_event(
         async with Actor:
 
             class WebhookHandler(BaseHTTPRequestHandler):
-                def do_GET(self) -> None:  # noqa: N802
+                def do_GET(self) -> None:
                     self.send_response(200)
                     self.end_headers()
                     self.wfile.write(bytes('Hello, world!', encoding='utf-8'))
 
-                def do_POST(self) -> None:  # noqa: N802
+                def do_POST(self) -> None:
                     nonlocal webhook_body
                     content_length = self.headers.get('content-length')
                     length = int(content_length) if content_length else 0

apify-2.7.1b5/tests/integration/test_crawlers_with_storages.py

@@ -0,0 +1,111 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .conftest import MakeActorFunction, RunActorFunction
+
+
+async def test_actor_on_platform_max_crawl_depth(
+    make_actor: MakeActorFunction,
+    run_actor: RunActorFunction,
+) -> None:
+    """Test that the actor respects max_crawl_depth."""
+
+    async def main() -> None:
+        """The crawler entry point."""
+        import re
+
+        from crawlee.crawlers import ParselCrawler, ParselCrawlingContext
+
+        from apify import Actor
+
+        async with Actor:
+            crawler = ParselCrawler(max_crawl_depth=2)
+            finished = []
+            enqueue_pattern = re.compile(r'http://localhost:8080/2+$')
+
+            @crawler.router.default_handler
+            async def default_handler(context: ParselCrawlingContext) -> None:
+                """Default request handler."""
+                context.log.info(f'Processing {context.request.url} ...')
+                await context.enqueue_links(include=[enqueue_pattern])
+                finished.append(context.request.url)
+
+            await crawler.run(['http://localhost:8080/'])
+            assert finished == ['http://localhost:8080/', 'http://localhost:8080/2', 'http://localhost:8080/22']
+
+    actor = await make_actor(label='crawler-max-depth', main_func=main)
+    run_result = await run_actor(actor)
+
+    assert run_result.status == 'SUCCEEDED'
+
+
+async def test_actor_on_platform_max_requests_per_crawl(
+    make_actor: MakeActorFunction,
+    run_actor: RunActorFunction,
+) -> None:
+    """Test that the actor respects max_requests_per_crawl."""
+
+    async def main() -> None:
+        """The crawler entry point."""
+        from crawlee import ConcurrencySettings
+        from crawlee.crawlers import ParselCrawler, ParselCrawlingContext
+
+        from apify import Actor
+
+        async with Actor:
+            crawler = ParselCrawler(
+                max_requests_per_crawl=3, concurrency_settings=ConcurrencySettings(max_concurrency=1)
+            )
+            finished = []
+
+            @crawler.router.default_handler
+            async def default_handler(context: ParselCrawlingContext) -> None:
+                """Default request handler."""
+                context.log.info(f'Processing {context.request.url} ...')
+                await context.enqueue_links()
+                finished.append(context.request.url)
+
+            await crawler.run(['http://localhost:8080/'])
+            assert len(finished) == 3
+
+    actor = await make_actor(label='crawler-max-requests', main_func=main)
+    run_result = await run_actor(actor)
+
+    assert run_result.status == 'SUCCEEDED'
+
+
+async def test_actor_on_platform_max_request_retries(
+    make_actor: MakeActorFunction,
+    run_actor: RunActorFunction,
+) -> None:
+    """Test that the actor respects max_request_retries."""
+
+    async def main() -> None:
+        """The crawler entry point."""
+        from crawlee.crawlers import BasicCrawlingContext, ParselCrawler, ParselCrawlingContext
+
+        from apify import Actor
+
+        async with Actor:
+            max_retries = 3
+            crawler = ParselCrawler(max_request_retries=max_retries)
+            failed_counter = 0
+
+            @crawler.error_handler
+            async def error_handler(_: BasicCrawlingContext, __: Exception) -> None:
+                nonlocal failed_counter
+                failed_counter += 1
+
+            @crawler.router.default_handler
+            async def default_handler(_: ParselCrawlingContext) -> None:
+                raise RuntimeError('Some error')
+
+            await crawler.run(['http://localhost:8080/'])
+            assert failed_counter == max_retries, f'{failed_counter=}'
+
+    actor = await make_actor(label='crawler-max-retries', main_func=main)
+    run_result = await run_actor(actor)
+
+    assert run_result.status == 'SUCCEEDED'