apify 3.0.4b1__tar.gz → 3.0.4b3__tar.gz

{apify-3.0.4b1 → apify-3.0.4b3}/CHANGELOG.md

@@ -8,6 +8,11 @@ All notable changes to this project will be documented in this file.
 ### 🐛 Bug Fixes
 
 - Fix type of `cloud_storage_client` in `SmartApifyStorageClient` ([#642](https://github.com/apify/apify-sdk-python/pull/642)) ([3bf285d](https://github.com/apify/apify-sdk-python/commit/3bf285d60f507730954986a80c19ed2e27a38f9c)) by [@vdusek](https://github.com/vdusek)
+- Fix local charging log dataset name ([#649](https://github.com/apify/apify-sdk-python/pull/649)) ([fdb1276](https://github.com/apify/apify-sdk-python/commit/fdb1276264aee2687596d87c96d19033fe915823)) by [@vdusek](https://github.com/vdusek), closes [#648](https://github.com/apify/apify-sdk-python/issues/648)
+
+### ⚡ Performance
+
+- Use Apify-provided environment variables to obtain PPE pricing information ([#644](https://github.com/apify/apify-sdk-python/pull/644)) ([0c32f29](https://github.com/apify/apify-sdk-python/commit/0c32f29d6a316f5bacc931595d694f262c925b2b)) by [@Mantisus](https://github.com/Mantisus), closes [#614](https://github.com/apify/apify-sdk-python/issues/614)
 
 
 <!-- git-cliff-unreleased-end -->

{apify-3.0.4b1 → apify-3.0.4b3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify
-Version: 3.0.4b1
+Version: 3.0.4b3
 Summary: Apify SDK for Python
 Project-URL: Apify Homepage, https://apify.com
 Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
@@ -228,7 +228,7 @@ Requires-Python: >=3.10
 Requires-Dist: apify-client<3.0.0,>=2.2.0
 Requires-Dist: apify-shared<3.0.0,>=2.0.0
 Requires-Dist: cachetools>=5.5.0
-Requires-Dist: crawlee<2.0.0,>=1.0.2
+Requires-Dist: crawlee<2.0.0,>=1.0.4
 Requires-Dist: cryptography>=42.0.0
 Requires-Dist: impit>=0.6.1
 Requires-Dist: lazy-object-proxy>=1.11.0

{apify-3.0.4b1 → apify-3.0.4b3}/docs/02_concepts/12_pay_per_event.mdx

@@ -47,6 +47,6 @@ It is encouraged to test your monetization code on your machine before releasing
 ACTOR_TEST_PAY_PER_EVENT=true python -m youractor
 ```
 
-If you also wish to see a log of all the events charged throughout the run, the Apify SDK keeps a log of charged events in a so called charging dataset. Your charging dataset can be found under the `charging_log` name (unless you change your storage settings, this dataset is stored in `storage/datasets/charging_log/`). Please note that this log is not available when running the Actor in production on the Apify platform.
+If you also wish to see a log of all the events charged throughout the run, the Apify SDK keeps a log of charged events in a so called charging dataset. Your charging dataset can be found under the `charging-log` name (unless you change your storage settings, this dataset is stored in `storage/datasets/charging-log/`). Please note that this log is not available when running the Actor in production on the Apify platform.
 
 Because pricing configuration is stored by the Apify platform, all events will have a default price of $1.

{apify-3.0.4b1 → apify-3.0.4b3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apify"
-version = "3.0.4b1"
+version = "3.0.4b3"
 description = "Apify SDK for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "support@apify.com" }]
 license = { file = "LICENSE" }
@@ -36,7 +36,7 @@ keywords = [
 dependencies = [
     "apify-client>=2.2.0,<3.0.0",
     "apify-shared>=2.0.0,<3.0.0",
-    "crawlee>=1.0.2,<2.0.0",
+    "crawlee>=1.0.4,<2.0.0",
     "cachetools>=5.5.0",
     "cryptography>=42.0.0",
     "impit>=0.6.1",

{apify-3.0.4b1 → apify-3.0.4b3}/src/apify/_charging.py

@@ -4,13 +4,20 @@ import math
 from dataclasses import dataclass
 from datetime import datetime, timezone
 from decimal import Decimal
-from typing import TYPE_CHECKING, Protocol
+from typing import TYPE_CHECKING, Protocol, TypedDict
 
 from pydantic import TypeAdapter
 
 from crawlee._utils.context import ensure_context
 
-from apify._models import ActorRun, PricingModel
+from apify._models import (
+    ActorRun,
+    FlatPricePerMonthActorPricingInfo,
+    FreeActorPricingInfo,
+    PayPerEventActorPricingInfo,
+    PricePerDatasetItemActorPricingInfo,
+    PricingModel,
+)
 from apify._utils import docs_group
 from apify.log import logger
 from apify.storages import Dataset
@@ -111,24 +118,16 @@ class ActorPricingInfo:
 class ChargingManagerImplementation(ChargingManager):
     """Implementation of the `ChargingManager` Protocol - this is only meant to be instantiated internally."""
 
-    LOCAL_CHARGING_LOG_DATASET_NAME = 'charging_log'
+    LOCAL_CHARGING_LOG_DATASET_NAME = 'charging-log'
 
     def __init__(self, configuration: Configuration, client: ApifyClientAsync) -> None:
         self._max_total_charge_usd = configuration.max_total_charge_usd or Decimal('inf')
+        self._configuration = configuration
         self._is_at_home = configuration.is_at_home
         self._actor_run_id = configuration.actor_run_id
         self._purge_charging_log_dataset = configuration.purge_on_start
         self._pricing_model: PricingModel | None = None
 
-        if configuration.test_pay_per_event:
-            if self._is_at_home:
-                raise ValueError(
-                    'Using the ACTOR_TEST_PAY_PER_EVENT environment variable is only supported '
-                    'in a local development environment'
-                )
-
-            self._pricing_model = 'PAY_PER_EVENT'
-
         self._client = client
         self._charging_log_dataset: Dataset | None = None
 
@@ -140,37 +139,46 @@ class ChargingManagerImplementation(ChargingManager):
 
     async def __aenter__(self) -> None:
         """Initialize the charging manager - this is called by the `Actor` class and shouldn't be invoked manually."""
-        self.active = True
-
-        if self._is_at_home:
-            # Running on the Apify platform - fetch pricing info for the current run.
-
-            if self._actor_run_id is None:
-                raise RuntimeError('Actor run ID not found even though the Actor is running on Apify')
+        # Validate config
+        if self._configuration.test_pay_per_event and self._is_at_home:
+            raise ValueError(
+                'Using the ACTOR_TEST_PAY_PER_EVENT environment variable is only supported '
+                'in a local development environment'
+            )
 
-            run = run_validator.validate_python(await self._client.run(self._actor_run_id).get())
-            if run is None:
-                raise RuntimeError('Actor run not found')
+        self.active = True
 
-            if run.pricing_info is not None:
-                self._pricing_model = run.pricing_info.pricing_model
+        # Retrieve pricing information from env vars or API
+        pricing_data = await self._fetch_pricing_info()
+        pricing_info = pricing_data['pricing_info']
+        charged_event_counts = pricing_data['charged_event_counts']
+        max_total_charge_usd = pricing_data['max_total_charge_usd']
 
-                if run.pricing_info.pricing_model == 'PAY_PER_EVENT':
-                    for event_name, event_pricing in run.pricing_info.pricing_per_event.actor_charge_events.items():
-                        self._pricing_info[event_name] = PricingInfoItem(
-                            price=event_pricing.event_price_usd,
-                            title=event_pricing.event_title,
-                        )
+        # Set pricing model
+        if self._configuration.test_pay_per_event:
+            self._pricing_model = 'PAY_PER_EVENT'
+        else:
+            self._pricing_model = pricing_info.pricing_model if pricing_info else None
+
+        # Load per-event pricing information
+        if pricing_info and pricing_info.pricing_model == 'PAY_PER_EVENT':
+            for event_name, event_pricing in pricing_info.pricing_per_event.actor_charge_events.items():
+                self._pricing_info[event_name] = PricingInfoItem(
+                    price=event_pricing.event_price_usd,
+                    title=event_pricing.event_title,
+                )
 
-                    self._max_total_charge_usd = run.options.max_total_charge_usd or self._max_total_charge_usd
+            self._max_total_charge_usd = max_total_charge_usd
 
-            for event_name, count in (run.charged_event_counts or {}).items():
-                price = self._pricing_info.get(event_name, PricingInfoItem(Decimal(), title='')).price
-                self._charging_state[event_name] = ChargingStateItem(
-                    charge_count=count,
-                    total_charged_amount=count * price,
-                )
+        # Load charged event counts
+        for event_name, count in charged_event_counts.items():
+            price = self._pricing_info.get(event_name, PricingInfoItem(Decimal(), title='')).price
+            self._charging_state[event_name] = ChargingStateItem(
+                charge_count=count,
+                total_charged_amount=count * price,
+            )
 
+        # Set up charging log dataset for local development
         if not self._is_at_home and self._pricing_model == 'PAY_PER_EVENT':
             # We are not running on the Apify platform, but PPE is enabled for testing - open a dataset that
             # will contain a log of all charge calls for debugging purposes.
@@ -328,6 +336,38 @@ class ChargingManagerImplementation(ChargingManager):
     def get_max_total_charge_usd(self) -> Decimal:
         return self._max_total_charge_usd
 
+    async def _fetch_pricing_info(self) -> _FetchedPricingInfoDict:
+        """Fetch pricing information from environment variables or API."""
+        # Check if pricing info is available via environment variables
+        if self._configuration.actor_pricing_info is not None and self._configuration.charged_event_counts is not None:
+            return _FetchedPricingInfoDict(
+                pricing_info=self._configuration.actor_pricing_info,
+                charged_event_counts=self._configuration.charged_event_counts,
+                max_total_charge_usd=self._configuration.max_total_charge_usd or Decimal('inf'),
+            )
+
+        # Fall back to API call
+        if self._is_at_home:
+            if self._actor_run_id is None:
+                raise RuntimeError('Actor run ID not found even though the Actor is running on Apify')
+
+            run = run_validator.validate_python(await self._client.run(self._actor_run_id).get())
+            if run is None:
+                raise RuntimeError('Actor run not found')
+
+            return _FetchedPricingInfoDict(
+                pricing_info=run.pricing_info,
+                charged_event_counts=run.charged_event_counts or {},
+                max_total_charge_usd=run.options.max_total_charge_usd or Decimal('inf'),
+            )
+
+        # Local development without environment variables
+        return _FetchedPricingInfoDict(
+            pricing_info=None,
+            charged_event_counts={},
+            max_total_charge_usd=self._configuration.max_total_charge_usd or Decimal('inf'),
+        )
+
 
 @dataclass
 class ChargingStateItem:
@@ -339,3 +379,15 @@ class ChargingStateItem:
 class PricingInfoItem:
     price: Decimal
     title: str
+
+
+class _FetchedPricingInfoDict(TypedDict):
+    pricing_info: (
+        FreeActorPricingInfo
+        | FlatPricePerMonthActorPricingInfo
+        | PricePerDatasetItemActorPricingInfo
+        | PayPerEventActorPricingInfo
+        | None
+    )
+    charged_event_counts: dict[str, int]
+    max_total_charge_usd: Decimal

{apify-3.0.4b1 → apify-3.0.4b3}/src/apify/_configuration.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import json
 from datetime import datetime, timedelta
 from decimal import Decimal
 from logging import getLogger
@@ -14,6 +15,12 @@ from crawlee._utils.models import timedelta_ms
 from crawlee._utils.urls import validate_http_url
 from crawlee.configuration import Configuration as CrawleeConfiguration
 
+from apify._models import (
+    FlatPricePerMonthActorPricingInfo,
+    FreeActorPricingInfo,
+    PayPerEventActorPricingInfo,
+    PricePerDatasetItemActorPricingInfo,
+)
 from apify._utils import docs_group
 
 logger = getLogger(__name__)
@@ -409,6 +416,29 @@ class Configuration(CrawleeConfiguration):
         ),
     ] = None
 
+    actor_pricing_info: Annotated[
+        FreeActorPricingInfo
+        | FlatPricePerMonthActorPricingInfo
+        | PricePerDatasetItemActorPricingInfo
+        | PayPerEventActorPricingInfo
+        | None,
+        Field(
+            alias='apify_actor_pricing_info',
+            description='JSON string with prising info of the actor',
+            discriminator='pricing_model',
+        ),
+        BeforeValidator(lambda data: json.loads(data) if isinstance(data, str) else data if data else None),
+    ] = None
+
+    charged_event_counts: Annotated[
+        dict[str, int] | None,
+        Field(
+            alias='apify_charged_actor_event_counts',
+            description='Counts of events that were charged for the actor',
+        ),
+        BeforeValidator(lambda data: json.loads(data) if isinstance(data, str) else data if data else None),
+    ] = None
+
     @model_validator(mode='after')
     def disable_browser_sandbox_on_platform(self) -> Self:
         """Disable the browser sandbox mode when running on the Apify platform.

{apify-3.0.4b1 → apify-3.0.4b3}/tests/integration/README.md

@@ -1,14 +1,25 @@
 # Integration tests
 
-We have integration tests which build and run Actors using the Python SDK on the Apify Platform. To run these tests, you need to set the `APIFY_TEST_USER_API_TOKEN` environment variable to the API token of the Apify user you want to use for the tests, and then start them with `make integration-tests`.
+There are two different groups of integration tests in this repository:
+- Apify API integration tests. These test that the Apify SDK is correctly communicating with Apify API through Apify client.
+- Actor integration tests. These test that the Apify SDK can be used in Actors deployed to Apify platform. These are very high level tests, and they test communication with the API and correct interaction with the Apify platform.
 
-If you want to run the integration tests on a different environment than the main Apify Platform, you need to set the `APIFY_INTEGRATION_TESTS_API_URL` environment variable to the right URL to the Apify API you want to use.
+To run these tests, you need to set the `APIFY_TEST_USER_API_TOKEN` environment variable to the API token of the Apify user you want to use for the tests, and then start them with `make integration-tests`.
 
-## How to write tests
+## Apify API integration tests
+The tests are making real requests to the Apify API as opposed to the unit tests that are mocking such API calls. On the other hand they are faster than `Actor integration tests` as they do not require building and deploying the Actor. These test can be also fully debugged locally. Preferably try to write integration tests on this level if possible.
+
+
+## Actor integration tests
+We have integration tests which build and run Actors using the Python SDK on the Apify platform. These integration tests are slower than `Apify API integration tests` as they need to build and deploy Actors on the platform. Preferably try to write `Apify API integration tests` first, and only write `Actor integration tests` when you need to test something that can only be tested on the platform.
+
+If you want to run the integration tests on a different environment than the main Apify platform, you need to set the `APIFY_INTEGRATION_TESTS_API_URL` environment variable to the right URL to the Apify API you want to use.
+
+### How to write tests
 
 There are two fixtures which you can use to write tests:
 
-### `apify_client_async`
+#### `apify_client_async`
 
 This fixture just gives you an instance of `ApifyClientAsync` configured with the right token and API URL, so you don't have to do that yourself.
 
@@ -17,15 +28,15 @@ async def test_something(apify_client_async: ApifyClientAsync) -> None:
     assert await apify_client_async.user('me').get() is not None
 ```
 
-### `make_actor`
+#### `make_actor`
 
-This fixture returns a factory function for creating Actors on the Apify Platform.
+This fixture returns a factory function for creating Actors on the Apify platform.
 
 For the Actor source, the fixture takes the files from `tests/integration/actor_source_base`, builds the Apify SDK wheel from the current codebase, and adds the Actor source you passed to the fixture as an argument. You have to pass exactly one of the `main_func`, `main_py` and `source_files` arguments.
 
 The created Actor will be uploaded to the platform, built there, and after the test finishes, it will be automatically deleted. If the Actor build fails, it will not be deleted, so that you can check why the build failed.
 
-### Creating test Actor straight from a Python function
+#### Creating test Actor straight from a Python function
 
 You can create Actors straight from a Python function. This is great because you can have the test Actor source code checked with the linter.
 
@@ -66,7 +77,7 @@ async def test_something(
     assert run_result.status == 'SUCCEEDED'
 ```
 
-### Creating Actor from source files
+#### Creating Actor from source files
 
 You can also pass the source files directly if you need something more complex (e.g. pass some fixed value to the Actor source code or use multiple source files).
 
@@ -127,7 +138,7 @@ async def test_something(
     assert actor_run.status == 'SUCCEEDED'
 ```
 
-### Asserts
+#### Asserts
 
 Since test Actors are not executed as standard pytest tests, we don't get introspection of assertion expressions. In case of failure, only a bare `AssertionError` is shown, without the left and right values. This means, we must include explicit assertion messages to aid potential debugging.
 

{apify-3.0.4b1/tests/integration → apify-3.0.4b3/tests/integration/actor}/conftest.py

@@ -13,111 +13,20 @@ import pytest
 from filelock import FileLock
 
 from apify_client import ApifyClient, ApifyClientAsync
-from apify_shared.consts import ActorJobStatus, ActorSourceType, ApifyEnvVars
-from crawlee import service_locator
+from apify_shared.consts import ActorJobStatus, ActorSourceType
 
-import apify._actor
-from ._utils import generate_unique_resource_name
-from apify import Actor
+from .._utils import generate_unique_resource_name
 from apify._models import ActorRun
-from apify.storage_clients import ApifyStorageClient
-from apify.storage_clients._apify._utils import AliasResolver
-from apify.storages import RequestQueue
 
 if TYPE_CHECKING:
-    from collections.abc import AsyncGenerator, Awaitable, Callable, Coroutine, Iterator, Mapping
+    from collections.abc import Awaitable, Callable, Coroutine, Iterator, Mapping
     from decimal import Decimal
 
     from apify_client.clients.resource_clients import ActorClientAsync
 
 _TOKEN_ENV_VAR = 'APIFY_TEST_USER_API_TOKEN'
 _API_URL_ENV_VAR = 'APIFY_INTEGRATION_TESTS_API_URL'
-_SDK_ROOT_PATH = Path(__file__).parent.parent.parent.resolve()
-
-
-@pytest.fixture
-def prepare_test_env(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> Callable[[], None]:
-    """Prepare the testing environment by resetting the global state before each test.
-
-    This fixture ensures that the global state of the package is reset to a known baseline before each test runs.
-    It also configures a temporary storage directory for test isolation.
-
-    Args:
-        monkeypatch: Test utility provided by pytest for patching.
-        tmp_path: A unique temporary directory path provided by pytest for test isolation.
-
-    Returns:
-        A callable that prepares the test environment.
-    """
-
-    def _prepare_test_env() -> None:
-        # Reset the Actor class state.
-        apify._actor.Actor.__wrapped__.__class__._is_any_instance_initialized = False  # type: ignore[attr-defined]
-        apify._actor.Actor.__wrapped__.__class__._is_rebooting = False  # type: ignore[attr-defined]
-        delattr(apify._actor.Actor, '__wrapped__')
-
-        # Set the environment variable for the local storage directory to the temporary path.
-        monkeypatch.setenv(ApifyEnvVars.LOCAL_STORAGE_DIR, str(tmp_path))
-
-        # Reset the services in the service locator.
-        service_locator._configuration = None
-        service_locator._event_manager = None
-        service_locator._storage_client = None
-        service_locator.storage_instance_manager.clear_cache()
-
-        # Reset the AliasResolver class state.
-        AliasResolver._alias_map = {}
-        AliasResolver._alias_init_lock = None
-
-        # Verify that the test environment was set up correctly.
-        assert os.environ.get(ApifyEnvVars.LOCAL_STORAGE_DIR) == str(tmp_path)
-
-    return _prepare_test_env
-
-
-@pytest.fixture(autouse=True)
-def _isolate_test_environment(prepare_test_env: Callable[[], None]) -> None:
-    """Isolate the testing environment by resetting global state before and after each test.
-
-    This fixture ensures that each test starts with a clean slate and that any modifications during the test
-    do not affect subsequent tests. It runs automatically for all tests.
-
-    Args:
-        prepare_test_env: Fixture to prepare the environment before each test.
-    """
-
-    prepare_test_env()
-
-
-@pytest.fixture(scope='session')
-def apify_token() -> str:
-    api_token = os.getenv(_TOKEN_ENV_VAR)
-
-    if not api_token:
-        raise RuntimeError(f'{_TOKEN_ENV_VAR} environment variable is missing, cannot run tests!')
-
-    return api_token
-
-
-@pytest.fixture(scope='session')
-def apify_client_async(apify_token: str) -> ApifyClientAsync:
-    """Create an instance of the ApifyClientAsync."""
-    api_url = os.getenv(_API_URL_ENV_VAR)
-
-    return ApifyClientAsync(apify_token, api_url=api_url)
-
-
-@pytest.fixture(params=['single', 'shared'])
-async def request_queue_apify(
-    apify_token: str, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest
-) -> AsyncGenerator[RequestQueue]:
-    """Create an instance of the Apify request queue on the platform and drop it when the test is finished."""
-    monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_token)
-
-    async with Actor:
-        rq = await RequestQueue.open(storage_client=ApifyStorageClient(request_queue_access=request.param))
-        yield rq
-        await rq.drop()
+_SDK_ROOT_PATH = Path(__file__).parent.parent.parent.parent.resolve()
 
 
 @pytest.fixture(scope='session')
@@ -167,8 +76,7 @@ def actor_base_source_files(sdk_wheel_path: Path) -> dict[str, str | bytes]:
     source_files: dict[str, str | bytes] = {}
 
     # First read the actor_source_base files
-    sdk_root_path = Path(__file__).parent.parent.parent.resolve()
-    actor_source_base_path = sdk_root_path / 'tests/integration/actor_source_base'
+    actor_source_base_path = _SDK_ROOT_PATH / 'tests/integration/actor/actor_source_base'
 
     for path in actor_source_base_path.glob('**/*'):
         if not path.is_file():
@@ -346,11 +254,9 @@ def make_actor(
 
     yield _make_actor
 
-    client = ApifyClient(token=apify_token, api_url=os.getenv(_API_URL_ENV_VAR))
-
     # Delete all the generated Actors.
     for actor_id in actors_for_cleanup:
-        actor_client = client.actor(actor_id)
+        actor_client = ApifyClient(token=apify_token, api_url=os.getenv(_API_URL_ENV_VAR)).actor(actor_id)
 
         if (actor := actor_client.get()) is not None:
             actor_client.update(
@@ -387,7 +293,7 @@ class RunActorFunction(Protocol):
 
 
 @pytest.fixture(scope='session')
-def run_actor(apify_token: str) -> RunActorFunction:
+def run_actor(apify_client_async: ApifyClientAsync) -> RunActorFunction:
     """Fixture for calling an Actor run and waiting for its completion.
 
     This fixture returns a function that initiates an Actor run with optional run input, waits for its completion,
@@ -408,8 +314,7 @@ def run_actor(apify_token: str) -> RunActorFunction:
         assert isinstance(call_result, dict), 'The result of ActorClientAsync.call() is not a dictionary.'
         assert 'id' in call_result, 'The result of ActorClientAsync.call() does not contain an ID.'
 
-        client = ApifyClientAsync(token=apify_token, api_url=os.getenv(_API_URL_ENV_VAR))
-        run_client = client.run(call_result['id'])
+        run_client = apify_client_async.run(call_result['id'])
         run_result = await run_client.wait_for_finish(wait_secs=600)
 
         return ActorRun.model_validate(run_result)

{apify-3.0.4b1/tests/integration → apify-3.0.4b3/tests/integration/actor}/test_actor_api_helpers.py

@@ -6,7 +6,7 @@ from typing import TYPE_CHECKING
 
 from crawlee._utils.crypto import crypto_random_object_id
 
-from ._utils import generate_unique_resource_name
+from .._utils import generate_unique_resource_name
 from apify import Actor
 from apify._models import ActorRun
 

{apify-3.0.4b1/tests/integration → apify-3.0.4b3/tests/integration/actor}/test_actor_dataset.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 
 from apify_shared.consts import ApifyEnvVars
 
-from ._utils import generate_unique_resource_name
+from .._utils import generate_unique_resource_name
 from apify import Actor
 
 if TYPE_CHECKING:

{apify-3.0.4b1/tests/integration → apify-3.0.4b3/tests/integration/actor}/test_actor_key_value_store.py

@@ -4,7 +4,7 @@ from typing import TYPE_CHECKING
 
 from apify_shared.consts import ApifyEnvVars
 
-from ._utils import generate_unique_resource_name
+from .._utils import generate_unique_resource_name
 from apify import Actor
 
 if TYPE_CHECKING:

{apify-3.0.4b1/tests/integration → apify-3.0.4b3/tests/integration/actor}/test_actor_lifecycle.py

@@ -122,7 +122,8 @@ async def test_actor_fails_correctly_with_exception(
 async def test_actor_with_crawler_reboot(make_actor: MakeActorFunction, run_actor: RunActorFunction) -> None:
     """Test that crawler in actor works as expected after reboot.
 
-    Handle two requests. Reboot in between the two requests."""
+    Handle two requests. Reboot in between the two requests. The second run should include statistics of the first run.
+    """
 
     async def main() -> None:
         from crawlee._types import BasicCrawlingContext, ConcurrencySettings
@@ -152,7 +153,8 @@ async def test_actor_with_crawler_reboot(make_actor: MakeActorFunction, run_acto
             await crawler.run(requests)
 
             # Each time one request is finished.
-            assert crawler.statistics.state.requests_finished == 1
+            expected_requests_finished = 1 if first_run else 2
+            assert crawler.statistics.state.requests_finished == expected_requests_finished
 
     actor = await make_actor(label='migration', main_func=main)
     run_result = await run_actor(actor)

{apify-3.0.4b1/tests/integration → apify-3.0.4b3/tests/integration/actor}/test_actor_log.py

@@ -2,17 +2,12 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-import pytest
-
 from apify import Actor, __version__
 
 if TYPE_CHECKING:
     from .conftest import MakeActorFunction, RunActorFunction
 
 
-# TODO: What to do with the `browserforge` output?
-# https://github.com/apify/apify-sdk-python/issues/423
-@pytest.mark.skip
 async def test_actor_logging(
     make_actor: MakeActorFunction,
     run_actor: RunActorFunction,
@@ -64,12 +59,15 @@ async def test_actor_logging(
     run_log_lines = [line[25:] for line in run_log_lines]
 
     # This might be way too specific and easy to break, but let's hope not
-    assert run_log_lines.pop(0).startswith('ACTOR: Pulling Docker image')
-    assert run_log_lines.pop(0) == 'ACTOR: Creating Docker container.'
-    assert run_log_lines.pop(0) == 'ACTOR: Starting Docker container.'
-    assert run_log_lines.pop(0) == '[apify] INFO  Initializing Actor...'
+    assert run_log_lines.pop(0).startswith('ACTOR: Pulling container image of build')
+    assert run_log_lines.pop(0) == 'ACTOR: Creating container.'
+    assert run_log_lines.pop(0) == 'ACTOR: Starting container.'
+    assert run_log_lines.pop(0) == (
+        '[apify._configuration] WARN  Actor is running on the Apify platform,'
+        ' `disable_browser_sandbox` was changed to True.'
+    )
     assert run_log_lines.pop(0).startswith(
-        f'[apify] INFO  System info ({{"apify_sdk_version": "{__version__}", "apify_client_version": "'
+        f'[apify] INFO  Initializing Actor ({{"apify_sdk_version": "{__version__}", "apify_client_version": "'
     )
     assert run_log_lines.pop(0) == '[apify] DEBUG Debug message'
     assert run_log_lines.pop(0) == '[apify] INFO  Info message'