apify 3.0.3b1__tar.gz → 3.0.4b2__tar.gz

{apify-3.0.3b1 → apify-3.0.4b2}/CHANGELOG.md

@@ -3,14 +3,26 @@
 All notable changes to this project will be documented in this file.
 
 <!-- git-cliff-unreleased-start -->
-## 3.0.3 - **not yet released**
+## 3.0.4 - **not yet released**
 
 ### 🐛 Bug Fixes
 
-- Cache requests in RQ implementations by `id` ([#633](https://github.com/apify/apify-sdk-python/pull/633)) ([76886ce](https://github.com/apify/apify-sdk-python/commit/76886ce496165346a01f67e018547287c211ea54)) by [@Pijukatel](https://github.com/Pijukatel), closes [#630](https://github.com/apify/apify-sdk-python/issues/630)
+- 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 -->
+## [3.0.3](https://github.com/apify/apify-sdk-python/releases/tag/v3.0.3) (2025-10-21)
+
+### 🐛 Bug Fixes
+
+- Cache requests in RQ implementations by `id` ([#633](https://github.com/apify/apify-sdk-python/pull/633)) ([76886ce](https://github.com/apify/apify-sdk-python/commit/76886ce496165346a01f67e018547287c211ea54)) by [@Pijukatel](https://github.com/Pijukatel), closes [#630](https://github.com/apify/apify-sdk-python/issues/630)
+
+
 ## [3.0.2](https://github.com/apify/apify-sdk-python/releases/tag/v3.0.2) (2025-10-17)
 
 ### 🐛 Bug Fixes

{apify-3.0.3b1 → apify-3.0.4b2}/PKG-INFO

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

{apify-3.0.3b1 → apify-3.0.4b2}/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.3b1 → apify-3.0.4b2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "apify"
-version = "3.0.3b1"
+version = "3.0.4b2"
 description = "Apify SDK for Python"
 authors = [{ name = "Apify Technologies s.r.o.", email = "support@apify.com" }]
 license = { file = "LICENSE" }

{apify-3.0.3b1 → apify-3.0.4b2}/src/apify/_actor.py

@@ -48,7 +48,6 @@ if TYPE_CHECKING:
     from typing_extensions import Self
 
     from crawlee.proxy_configuration import _NewUrlFunction
-    from crawlee.storage_clients import StorageClient
 
     from apify._models import Webhook
 
@@ -140,7 +139,6 @@ class _ActorType:
         # `__init__` method should not be considered final.
 
         self._apify_client: ApifyClientAsync | None = None
-        self._local_storage_client: StorageClient | None = None
 
         self._is_exiting = False
         self._is_initialized = False

{apify-3.0.3b1 → apify-3.0.4b2}/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.3b1 → apify-3.0.4b2}/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.3b1 → apify-3.0.4b2}/src/apify/storage_clients/_apify/_models.py

@@ -120,7 +120,7 @@ class RequestQueueStats(BaseModel):
     """The number of request queue reads."""
 
     storage_bytes: Annotated[int, Field(alias='storageBytes', default=0)]
-    """Storage size in Bytes."""
+    """Storage size in bytes."""
 
     write_count: Annotated[int, Field(alias='writeCount', default=0)]
     """The number of request queue writes."""

apify-3.0.4b2/src/apify/storage_clients/_apify/_storage_client.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+from typing_extensions import override
+
+from crawlee.storage_clients._base import StorageClient
+
+from ._dataset_client import ApifyDatasetClient
+from ._key_value_store_client import ApifyKeyValueStoreClient
+from ._request_queue_client import ApifyRequestQueueClient
+from ._utils import hash_api_base_url_and_token
+from apify._configuration import Configuration as ApifyConfiguration
+from apify._utils import docs_group
+
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+
+    from crawlee.configuration import Configuration as CrawleeConfiguration
+
+
+@docs_group('Storage clients')
+class ApifyStorageClient(StorageClient):
+    """Apify platform implementation of the storage client.
+
+    This storage client provides access to datasets, key-value stores, and request queues that persist data
+    to the Apify platform. Each storage type is implemented with its own specific Apify client that stores data
+    in the cloud, making it accessible from anywhere.
+
+    The communication with the Apify platform is handled via the Apify API client for Python, which is an HTTP API
+    wrapper. For maximum efficiency and performance of the storage clients, various caching mechanisms are used to
+    minimize the number of API calls made to the Apify platform. Data can be inspected and manipulated through
+    the Apify console web interface or via the Apify API.
+
+    The request queue client supports two access modes controlled by the `request_queue_access` parameter:
+
+    ### Single mode
+
+    The `single` mode is optimized for scenarios with only one consumer. It minimizes API calls, making it faster
+    and more cost-efficient compared to the `shared` mode. This option is ideal when a single Actor is responsible
+    for consuming the entire request queue. Using multiple consumers simultaneously may lead to inconsistencies
+    or unexpected behavior.
+
+    In this mode, multiple producers can safely add new requests, but forefront requests may not be processed
+    immediately, as the client relies on local head estimation instead of frequent forefront fetching. Requests can
+    also be added or marked as handled by other clients, but they must not be deleted or modified, since such changes
+    would not be reflected in the local cache. If a request is already fully cached locally, marking it as handled
+    by another client will be ignored by this client. This does not cause errors but can occasionally result in
+    reprocessing a request that was already handled elsewhere. If the request was not yet cached locally, marking
+    it as handled poses no issue.
+
+    ### Shared mode
+
+    The `shared` mode is designed for scenarios with multiple concurrent consumers. It ensures proper synchronization
+    and consistency across clients, at the cost of higher API usage and slightly worse performance. This mode is safe
+    for concurrent access from multiple processes, including Actors running in parallel on the Apify platform. It
+    should be used when multiple consumers need to process requests from the same queue simultaneously.
+    """
+
+    _LSP_ERROR_MSG = 'Expected "configuration" to be an instance of "apify.Configuration", but got {} instead.'
+    """This class (intentionally) violates the Liskov Substitution Principle.
+
+    It requires a specialized `Configuration` instance compared to its parent class.
+    """
+
+    def __init__(self, *, request_queue_access: Literal['single', 'shared'] = 'single') -> None:
+        """Initialize a new instance.
+
+        Args:
+            request_queue_access: Defines how the request queue client behaves. Use `single` mode for a single
+                consumer. It has fewer API calls, meaning better performance and lower costs. If you need multiple
+                concurrent consumers use `shared` mode, but expect worse performance and higher costs due to
+                the additional overhead.
+        """
+        self._request_queue_access = request_queue_access
+
+    @override
+    async def create_dataset_client(
+        self,
+        *,
+        id: str | None = None,
+        name: str | None = None,
+        alias: str | None = None,
+        configuration: CrawleeConfiguration | None = None,
+    ) -> ApifyDatasetClient:
+        configuration = configuration or ApifyConfiguration.get_global_configuration()
+        if isinstance(configuration, ApifyConfiguration):
+            return await ApifyDatasetClient.open(id=id, name=name, alias=alias, configuration=configuration)
+
+        raise TypeError(self._LSP_ERROR_MSG.format(type(configuration).__name__))
+
+    @override
+    async def create_kvs_client(
+        self,
+        *,
+        id: str | None = None,
+        name: str | None = None,
+        alias: str | None = None,
+        configuration: CrawleeConfiguration | None = None,
+    ) -> ApifyKeyValueStoreClient:
+        configuration = configuration or ApifyConfiguration.get_global_configuration()
+        if isinstance(configuration, ApifyConfiguration):
+            return await ApifyKeyValueStoreClient.open(id=id, name=name, alias=alias, configuration=configuration)
+
+        raise TypeError(self._LSP_ERROR_MSG.format(type(configuration).__name__))
+
+    @override
+    async def create_rq_client(
+        self,
+        *,
+        id: str | None = None,
+        name: str | None = None,
+        alias: str | None = None,
+        configuration: CrawleeConfiguration | None = None,
+    ) -> ApifyRequestQueueClient:
+        configuration = configuration or ApifyConfiguration.get_global_configuration()
+        if isinstance(configuration, ApifyConfiguration):
+            return await ApifyRequestQueueClient.open(
+                id=id, name=name, alias=alias, configuration=configuration, access=self._request_queue_access
+            )
+
+        raise TypeError(self._LSP_ERROR_MSG.format(type(configuration).__name__))
+
+    @override
+    def get_storage_client_cache_key(self, configuration: CrawleeConfiguration) -> Hashable:
+        if isinstance(configuration, ApifyConfiguration):
+            # It is not supported to open exactly same queue with 'single' and 'shared' client at the same time.
+            # Whichever client variation gets used first, wins.
+            return super().get_storage_client_cache_key(configuration), hash_api_base_url_and_token(configuration)
+
+        config_class = type(configuration)
+        raise TypeError(self._LSP_ERROR_MSG.format(f'{config_class.__module__}.{config_class.__name__}'))

{apify-3.0.3b1 → apify-3.0.4b2}/src/apify/storage_clients/_smart_apify/_storage_client.py

@@ -8,8 +8,7 @@ from crawlee.storage_clients._base import DatasetClient, KeyValueStoreClient, Re
 
 from apify._configuration import Configuration as ApifyConfiguration
 from apify._utils import docs_group
-from apify.storage_clients import ApifyStorageClient
-from apify.storage_clients._file_system import ApifyFileSystemStorageClient
+from apify.storage_clients import ApifyStorageClient, FileSystemStorageClient
 
 if TYPE_CHECKING:
     from collections.abc import Hashable
@@ -19,28 +18,36 @@ if TYPE_CHECKING:
 
 @docs_group('Storage clients')
 class SmartApifyStorageClient(StorageClient):
-    """SmartApifyStorageClient that delegates to cloud_storage_client or local_storage_client.
+    """Storage client that automatically selects cloud or local storage client based on the environment.
 
-    When running on Apify platform use cloud_storage_client, else use local_storage_client. This storage client is
-    designed to work specifically in Actor context.
+    This storage client provides access to datasets, key-value stores, and request queues by intelligently
+    delegating to either the cloud or local storage client based on the execution environment and configuration.
+
+    When running on the Apify platform (which is detected via environment variables), this client automatically
+    uses the `cloud_storage_client` to store storage data there. When running locally, it uses the
+    `local_storage_client` to store storage data there. You can also force cloud storage usage from your
+    local machine by using the `force_cloud` argument.
+
+    This storage client is designed to work specifically in `Actor` context and provides a seamless development
+    experience where the same code works both locally and on the Apify platform without any changes.
     """
 
     def __init__(
         self,
         *,
-        cloud_storage_client: ApifyStorageClient | None = None,
+        cloud_storage_client: StorageClient | None = None,
         local_storage_client: StorageClient | None = None,
     ) -> None:
-        """Initialize the Apify storage client.
+        """Initialize a new instance.
 
         Args:
-            cloud_storage_client: Client used to communicate with the Apify platform storage. Either through
-                `force_cloud` argument when opening storages or automatically when running on the Apify platform.
-            local_storage_client: Client used to communicate with the storage when not running on the Apify
-                platform and not using `force_cloud` argument when opening storages.
+            cloud_storage_client: Storage client used when an Actor is running on the Apify platform, or when
+                explicitly enabled via the `force_cloud` argument. Defaults to `ApifyStorageClient`.
+            local_storage_client: Storage client used when an Actor is not running on the Apify platform and when
+                `force_cloud` flag is not set. Defaults to `FileSystemStorageClient`.
         """
-        self._cloud_storage_client = cloud_storage_client or ApifyStorageClient(request_queue_access='single')
-        self._local_storage_client = local_storage_client or ApifyFileSystemStorageClient()
+        self._cloud_storage_client = cloud_storage_client or ApifyStorageClient()
+        self._local_storage_client = local_storage_client or FileSystemStorageClient()
 
     def __str__(self) -> str:
         return (
@@ -48,26 +55,6 @@ class SmartApifyStorageClient(StorageClient):
             f' local_storage_client={self._local_storage_client.__class__.__name__})'
         )
 
-    def get_suitable_storage_client(self, *, force_cloud: bool = False) -> StorageClient:
-        """Get a suitable storage client based on the global configuration and the value of the force_cloud flag.
-
-        Args:
-            force_cloud: If True, return `cloud_storage_client`.
-        """
-        if ApifyConfiguration.get_global_configuration().is_at_home:
-            return self._cloud_storage_client
-
-        configuration = ApifyConfiguration.get_global_configuration()
-        if force_cloud:
-            if configuration.token is None:
-                raise RuntimeError(
-                    'In order to use the Apify cloud storage from your computer, '
-                    'you need to provide an Apify token using the APIFY_TOKEN environment variable.'
-                )
-            return self._cloud_storage_client
-
-        return self._local_storage_client
-
     @override
     def get_storage_client_cache_key(self, configuration: CrawleeConfiguration) -> Hashable:
         if ApifyConfiguration.get_global_configuration().is_at_home:
@@ -115,3 +102,23 @@ class SmartApifyStorageClient(StorageClient):
         return await self.get_suitable_storage_client().create_rq_client(
             id=id, name=id, alias=alias, configuration=configuration
         )
+
+    def get_suitable_storage_client(self, *, force_cloud: bool = False) -> StorageClient:
+        """Get a suitable storage client based on the global configuration and the value of the force_cloud flag.
+
+        Args:
+            force_cloud: If True, return `cloud_storage_client`.
+        """
+        if ApifyConfiguration.get_global_configuration().is_at_home:
+            return self._cloud_storage_client
+
+        configuration = ApifyConfiguration.get_global_configuration()
+        if force_cloud:
+            if configuration.token is None:
+                raise RuntimeError(
+                    'In order to use the Apify cloud storage from your computer, '
+                    'you need to provide an Apify token using the APIFY_TOKEN environment variable.'
+                )
+            return self._cloud_storage_client
+
+        return self._local_storage_client

{apify-3.0.3b1 → apify-3.0.4b2}/tests/integration/test_actor_lifecycle.py

@@ -2,6 +2,8 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
+import pytest
+
 from apify import Actor
 
 if TYPE_CHECKING:
@@ -119,6 +121,7 @@ async def test_actor_fails_correctly_with_exception(
     assert run_result.status == 'FAILED'
 
 
+@pytest.mark.skip(reason='Skipped due to known instability, see issue #650.')
 async def test_actor_with_crawler_reboot(make_actor: MakeActorFunction, run_actor: RunActorFunction) -> None:
     """Test that crawler in actor works as expected after reboot.
 

{apify-3.0.3b1 → apify-3.0.4b2}/tests/integration/test_actor_log.py

@@ -12,7 +12,7 @@ if TYPE_CHECKING:
 
 # TODO: What to do with the `browserforge` output?
 # https://github.com/apify/apify-sdk-python/issues/423
-@pytest.mark.skip
+@pytest.mark.skip(reason='Skipped due to known instability, see issue #423.')
 async def test_actor_logging(
     make_actor: MakeActorFunction,
     run_actor: RunActorFunction,