apify 3.0.0rc1__py3-none-any.whl → 3.0.1__py3-none-any.whl

apify/storage_clients/_apify/_utils.py

@@ -0,0 +1,194 @@
+from __future__ import annotations
+
+import logging
+import re
+from asyncio import Lock
+from base64 import b64encode
+from hashlib import sha256
+from logging import getLogger
+from typing import TYPE_CHECKING, ClassVar
+
+from apify_client import ApifyClientAsync
+from crawlee._utils.crypto import compute_short_hash
+
+from apify._configuration import Configuration
+
+if TYPE_CHECKING:
+    from types import TracebackType
+
+    from apify_client.clients import KeyValueStoreClientAsync
+    from crawlee.storages import Dataset, KeyValueStore, RequestQueue
+
+
+logger = getLogger(__name__)
+
+
+class AliasResolver:
+    """Class for handling aliases.
+
+    The purpose of this is class is to ensure that alias storages are created with correct id. This is achieved by using
+    default kvs as a storage for global mapping of aliases to storage ids. Same mapping is also kept in memory to avoid
+    unnecessary calls to API and also have limited support of alias storages when not running on Apify platform. When on
+     Apify platform, the storages created with alias are accessible by the same alias even after migration or reboot.
+    """
+
+    _alias_map: ClassVar[dict[str, str]] = {}
+    """Map containing pre-existing alias storages and their ids. Global for all instances."""
+    _alias_init_lock: Lock | None = None
+    """Lock for creating alias storages. Only one alias storage can be created at the time. Global for all instances."""
+
+    _ALIAS_STORAGE_KEY_SEPARATOR = ','
+    _ALIAS_MAPPING_KEY = '__STORAGE_ALIASES_MAPPING'
+
+    def __init__(
+        self, storage_type: type[Dataset | KeyValueStore | RequestQueue], alias: str, configuration: Configuration
+    ) -> None:
+        self._storage_type = storage_type
+        self._alias = alias
+        self._additional_cache_key = hash_api_base_url_and_token(configuration)
+
+    async def __aenter__(self) -> AliasResolver:
+        """Context manager to prevent race condition in alias creation."""
+        lock = await self._get_alias_init_lock()
+        await lock.acquire()
+        return self
+
+    async def __aexit__(
+        self, exc_type: type[BaseException] | None, exc_value: BaseException | None, exc_traceback: TracebackType | None
+    ) -> None:
+        lock = await self._get_alias_init_lock()
+        lock.release()
+
+    @classmethod
+    async def _get_alias_init_lock(cls) -> Lock:
+        """Get lock for controlling the creation of the alias storages.
+
+        The lock is shared for all instances of the AliasResolver class.
+        It is created in async method to ensure that some event loop is already running.
+        """
+        if cls._alias_init_lock is None:
+            cls._alias_init_lock = Lock()
+        return cls._alias_init_lock
+
+    @classmethod
+    async def _get_alias_map(cls) -> dict[str, str]:
+        """Get the aliases and storage ids mapping from the default kvs.
+
+        Mapping is loaded from kvs only once and is shared for all instances of the AliasResolver class.
+
+        Returns:
+            Map of aliases and storage ids.
+        """
+        if not cls._alias_map and Configuration.get_global_configuration().is_at_home:
+            default_kvs_client = await _get_default_kvs_client()
+
+            record = await default_kvs_client.get_record(cls._ALIAS_MAPPING_KEY)
+
+            # get_record can return {key: ..., value: ..., content_type: ...}
+            if isinstance(record, dict):
+                if 'value' in record and isinstance(record['value'], dict):
+                    cls._alias_map = record['value']
+                else:
+                    cls._alias_map = record
+            else:
+                cls._alias_map = dict[str, str]()
+
+        return cls._alias_map
+
+    async def resolve_id(self) -> str | None:
+        """Get id of the aliased storage.
+
+        Either locate the id in the in-memory mapping or create the new storage.
+
+        Returns:
+            Storage id if it exists, None otherwise.
+        """
+        return (await self._get_alias_map()).get(self._storage_key, None)
+
+    async def store_mapping(self, storage_id: str) -> None:
+        """Add alias and related storage id to the mapping in default kvs and local in-memory mapping."""
+        # Update in-memory mapping
+        (await self._get_alias_map())[self._storage_key] = storage_id
+        if not Configuration.get_global_configuration().is_at_home:
+            logging.getLogger(__name__).debug(
+                'AliasResolver storage limited retention is only supported on Apify platform. Storage is not exported.'
+            )
+            return
+
+        default_kvs_client = await _get_default_kvs_client()
+        await default_kvs_client.get()
+
+        try:
+            record = await default_kvs_client.get_record(self._ALIAS_MAPPING_KEY)
+
+            # get_record can return {key: ..., value: ..., content_type: ...}
+            if isinstance(record, dict) and 'value' in record:
+                record = record['value']
+
+            # Update or create the record with the new alias mapping
+            if isinstance(record, dict):
+                record[self._storage_key] = storage_id
+            else:
+                record = {self._storage_key: storage_id}
+
+            # Store the mapping back in the KVS.
+            await default_kvs_client.set_record(self._ALIAS_MAPPING_KEY, record)
+        except Exception as exc:
+            logger.warning(f'Error storing alias mapping for {self._alias}: {exc}')
+
+    @property
+    def _storage_key(self) -> str:
+        """Get a unique storage key used for storing the alias in the mapping."""
+        return self._ALIAS_STORAGE_KEY_SEPARATOR.join(
+            [
+                self._storage_type.__name__,
+                self._alias,
+                self._additional_cache_key,
+            ]
+        )
+
+
+async def _get_default_kvs_client() -> KeyValueStoreClientAsync:
+    """Get a client for the default key-value store."""
+    configuration = Configuration.get_global_configuration()
+
+    apify_client_async = ApifyClientAsync(
+        token=configuration.token,
+        api_url=configuration.api_base_url,
+        max_retries=8,
+        min_delay_between_retries_millis=500,
+        timeout_secs=360,
+    )
+    if not configuration.default_key_value_store_id:
+        raise ValueError("'Configuration.default_key_value_store_id' must be set.")
+    return apify_client_async.key_value_store(key_value_store_id=configuration.default_key_value_store_id)
+
+
+def hash_api_base_url_and_token(configuration: Configuration) -> str:
+    """Hash configuration.api_public_base_url and configuration.token in deterministic way."""
+    if configuration.api_public_base_url is None or configuration.token is None:
+        raise ValueError("'Configuration.api_public_base_url' and 'Configuration.token' must be set.")
+    return compute_short_hash(f'{configuration.api_public_base_url}{configuration.token}'.encode())
+
+
+def unique_key_to_request_id(unique_key: str, *, request_id_length: int = 15) -> str:
+    """Generate a deterministic request ID based on a unique key.
+
+    Args:
+        unique_key: The unique key to convert into a request ID.
+        request_id_length: The length of the request ID.
+
+    Returns:
+        A URL-safe, truncated request ID based on the unique key.
+    """
+    # Encode the unique key and compute its SHA-256 hash
+    hashed_key = sha256(unique_key.encode('utf-8')).digest()
+
+    # Encode the hash in base64 and decode it to get a string
+    base64_encoded = b64encode(hashed_key).decode('utf-8')
+
+    # Remove characters that are not URL-safe ('+', '/', or '=')
+    url_safe_key = re.sub(r'(\+|\/|=)', '', base64_encoded)
+
+    # Truncate the key to the desired length
+    return url_safe_key[:request_id_length]

apify/storage_clients/_file_system/_key_value_store_client.py

@@ -1,12 +1,19 @@
 import asyncio
+import json
+import logging
 
-from typing_extensions import override
+from more_itertools import flatten
+from typing_extensions import Self, override
 
 from crawlee._consts import METADATA_FILENAME
+from crawlee.configuration import Configuration as CrawleeConfiguration
 from crawlee.storage_clients._file_system import FileSystemKeyValueStoreClient
+from crawlee.storage_clients.models import KeyValueStoreRecord
 
 from apify._configuration import Configuration
 
+logger = logging.getLogger(__name__)
+
 
 class ApifyFileSystemKeyValueStoreClient(FileSystemKeyValueStoreClient):
     """Apify-specific implementation of the `FileSystemKeyValueStoreClient`.
@@ -15,6 +22,22 @@ class ApifyFileSystemKeyValueStoreClient(FileSystemKeyValueStoreClient):
     directory, except for the metadata file and the `INPUT.json` file.
     """
 
+    @override
+    @classmethod
+    async def open(
+        cls,
+        *,
+        id: str | None,
+        name: str | None,
+        alias: str | None,
+        configuration: CrawleeConfiguration,
+    ) -> Self:
+        client = await super().open(id=id, name=name, alias=alias, configuration=configuration)
+
+        await client._sanitize_input_json_files()  # noqa: SLF001 - it's okay, this is a factory method
+
+        return client
+
     @override
     async def purge(self) -> None:
         """Purges the key-value store by deleting all its contents.
@@ -22,10 +45,16 @@ class ApifyFileSystemKeyValueStoreClient(FileSystemKeyValueStoreClient):
         It deletes all files in the key-value store directory, except for the metadata file and
         the `INPUT.json` file. It also updates the metadata to reflect that the store has been purged.
         """
-        kvs_input_key = Configuration.get_global_configuration().input_key
+        configuration = Configuration.get_global_configuration()
+
         async with self._lock:
+            files_to_keep = set(
+                flatten([key, f'{key}.{METADATA_FILENAME}'] for key in configuration.input_key_candidates)
+            )
+            files_to_keep.add(METADATA_FILENAME)
+
             for file_path in self.path_to_kvs.glob('*'):
-                if file_path.name in {METADATA_FILENAME, f'{kvs_input_key}.json'}:
+                if file_path.name in files_to_keep:
                     continue
                 if file_path.is_file():
                     await asyncio.to_thread(file_path.unlink, missing_ok=True)
@@ -34,3 +63,41 @@ class ApifyFileSystemKeyValueStoreClient(FileSystemKeyValueStoreClient):
                 update_accessed_at=True,
                 update_modified_at=True,
             )
+
+    async def _sanitize_input_json_files(self) -> None:
+        """Handle missing metadata for input files."""
+        configuration = Configuration.get_global_configuration()
+        alternative_keys = configuration.input_key_candidates - {configuration.canonical_input_key}
+
+        if (self.path_to_kvs / configuration.canonical_input_key).exists():
+            # Refresh metadata to prevent inconsistencies
+            input_data = await asyncio.to_thread(
+                lambda: json.loads((self.path_to_kvs / configuration.canonical_input_key).read_text())
+            )
+            await self.set_value(key=configuration.canonical_input_key, value=input_data)
+
+            for alternative_key in alternative_keys:
+                if (alternative_input_file := self.path_to_kvs / alternative_key).exists():
+                    logger.warning(f'Redundant input file found: {alternative_input_file}')
+        else:
+            for alternative_key in alternative_keys:
+                alternative_input_file = self.path_to_kvs / alternative_key
+
+                # Only process files that actually exist
+                if alternative_input_file.exists():
+                    # Refresh metadata to prevent inconsistencies
+                    with alternative_input_file.open() as f:
+                        input_data = await asyncio.to_thread(lambda: json.load(f))
+                    await self.set_value(key=alternative_key, value=input_data)
+
+    @override
+    async def get_value(self, *, key: str) -> KeyValueStoreRecord | None:
+        configuration = Configuration.get_global_configuration()
+
+        if key in configuration.input_key_candidates:
+            for candidate in configuration.input_key_candidates:
+                value = await super().get_value(key=candidate)
+                if value is not None:
+                    return value
+
+        return await super().get_value(key=key)

apify/storage_clients/_file_system/_storage_client.py

@@ -27,9 +27,15 @@ class ApifyFileSystemStorageClient(FileSystemStorageClient):
         *,
         id: str | None = None,
         name: str | None = None,
+        alias: str | None = None,
         configuration: Configuration | None = None,
     ) -> FileSystemKeyValueStoreClient:
         configuration = configuration or Configuration.get_global_configuration()
-        client = await ApifyFileSystemKeyValueStoreClient.open(id=id, name=name, configuration=configuration)
+        client = await ApifyFileSystemKeyValueStoreClient.open(
+            id=id,
+            name=name,
+            alias=alias,
+            configuration=configuration,
+        )
         await self._purge_if_needed(client, configuration)
         return client

apify/storage_clients/_smart_apify/__init__.py

@@ -0,0 +1 @@
+from ._storage_client import SmartApifyStorageClient

apify/storage_clients/_smart_apify/_storage_client.py

@@ -0,0 +1,117 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import override
+
+from crawlee.storage_clients._base import DatasetClient, KeyValueStoreClient, RequestQueueClient, StorageClient
+
+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
+
+if TYPE_CHECKING:
+    from collections.abc import Hashable
+
+    from crawlee.configuration import Configuration as CrawleeConfiguration
+
+
+@docs_group('Storage clients')
+class SmartApifyStorageClient(StorageClient):
+    """SmartApifyStorageClient that delegates to cloud_storage_client or local_storage_client.
+
+    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.
+    """
+
+    def __init__(
+        self,
+        *,
+        cloud_storage_client: ApifyStorageClient | None = None,
+        local_storage_client: StorageClient | None = None,
+    ) -> None:
+        """Initialize the Apify storage client.
+
+        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.
+        """
+        self._cloud_storage_client = cloud_storage_client or ApifyStorageClient(request_queue_access='single')
+        self._local_storage_client = local_storage_client or ApifyFileSystemStorageClient()
+
+    def __str__(self) -> str:
+        return (
+            f'{self.__class__.__name__}(cloud_storage_client={self._cloud_storage_client.__class__.__name__},'
+            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:
+            if isinstance(configuration, ApifyConfiguration):
+                return self._cloud_storage_client.get_storage_client_cache_key(configuration)
+            raise TypeError('Expecting ApifyConfiguration')
+
+        return self._local_storage_client.get_storage_client_cache_key(configuration)
+
+    @override
+    async def create_dataset_client(
+        self,
+        *,
+        id: str | None = None,
+        name: str | None = None,
+        alias: str | None = None,
+        configuration: CrawleeConfiguration | None = None,
+    ) -> DatasetClient:
+        return await self.get_suitable_storage_client().create_dataset_client(
+            id=id, name=id, alias=alias, configuration=configuration
+        )
+
+    @override
+    async def create_kvs_client(
+        self,
+        *,
+        id: str | None = None,
+        name: str | None = None,
+        alias: str | None = None,
+        configuration: CrawleeConfiguration | None = None,
+    ) -> KeyValueStoreClient:
+        return await self.get_suitable_storage_client().create_kvs_client(
+            id=id, name=id, alias=alias, configuration=configuration
+        )
+
+    @override
+    async def create_rq_client(
+        self,
+        *,
+        id: str | None = None,
+        name: str | None = None,
+        alias: str | None = None,
+        configuration: CrawleeConfiguration | None = None,
+    ) -> RequestQueueClient:
+        return await self.get_suitable_storage_client().create_rq_client(
+            id=id, name=id, alias=alias, configuration=configuration
+        )

{apify-3.0.0rc1.dist-info → apify-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify
-Version: 3.0.0rc1
+Version: 3.0.1
 Summary: Apify SDK for Python
 Project-URL: Apify Homepage, https://apify.com
 Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
@@ -228,10 +228,10 @@ Requires-Python: >=3.10
 Requires-Dist: apify-client<3.0.0,>=2.0.0
 Requires-Dist: apify-shared<3.0.0,>=2.0.0
 Requires-Dist: cachetools>=5.5.0
-Requires-Dist: crawlee==1.0.0rc1
+Requires-Dist: crawlee<2.0.0,>=1.0.2
 Requires-Dist: cryptography>=42.0.0
-Requires-Dist: impit>=0.5.3
-Requires-Dist: lazy-object-proxy<1.11.0
+Requires-Dist: impit>=0.6.1
+Requires-Dist: lazy-object-proxy>=1.11.0
 Requires-Dist: more-itertools>=10.2.0
 Requires-Dist: typing-extensions>=4.1.0
 Requires-Dist: websockets>=14.0
@@ -240,7 +240,22 @@ Provides-Extra: scrapy
 Requires-Dist: scrapy>=2.11.0; extra == 'scrapy'
 Description-Content-Type: text/markdown
 
-# Apify SDK for Python
+<h1 align=center>Apify SDK for Python</h1>
+
+<p align=center>
+    <a href="https://badge.fury.io/py/apify" rel="nofollow">
+        <img src="https://badge.fury.io/py/apify.svg" alt="PyPI version" style="max-width: 100%;">
+    </a>
+    <a href="https://pypi.org/project/apify/" rel="nofollow">
+        <img src="https://img.shields.io/pypi/dm/apify" alt="PyPI - Downloads" style="max-width: 100%;">
+    </a>
+    <a href="https://pypi.org/project/apify/" rel="nofollow">
+        <img src="https://img.shields.io/pypi/pyversions/apify" alt="PyPI - Python Version" style="max-width: 100%;">
+    </a>
+    <a href="https://discord.gg/jyEM2PRvMU" rel="nofollow">
+        <img src="https://img.shields.io/discord/801163717915574323?label=discord" alt="Chat on discord" style="max-width: 100%;">
+    </a>
+</p>
 
 The Apify SDK for Python is the official library to create [Apify Actors](https://docs.apify.com/platform/actors)
 in Python. It provides useful features like Actor lifecycle management, local storage emulation, and Actor

{apify-3.0.0rc1.dist-info → apify-3.0.1.dist-info}/RECORD

@@ -1,7 +1,7 @@
 apify/__init__.py,sha256=HpgKg2FZWJuSPfDygzJ62psylhw4NN4tKFnoYUIhcd4,838
-apify/_actor.py,sha256=kOEvs_3TxjZ1PlwLEnIEL5nAD12oKs0ULldYyI-9irw,52985
-apify/_charging.py,sha256=mJ-BueULWZxqvbdM_WGbsb-V3vTJ8Gw38k81eGwJhVY,12481
-apify/_configuration.py,sha256=Ta-qPlKenLaI0IOlODg_A4ZwmPtnuS7OWLSJyexcqmA,13283
+apify/_actor.py,sha256=DYHoyBAu6hDLs0BcTZL-IQveLK8gPTWvb6AgDnJc3EA,54755
+apify/_charging.py,sha256=KjZ2DnEMS0Tt8ibizmmt0RwBq8FOAsD1z-hKFgdazcY,13143
+apify/_configuration.py,sha256=7ZHhgRp98kr35zx4k4EB2aImq7Dq1FJjPg7r5bucv_M,14984
 apify/_consts.py,sha256=CjhyEJ4Mi0lcIrzfqz8dN7nPJWGjCeBrrXQy1PZ6zRI,440
 apify/_crypto.py,sha256=tqUs13QkemDtGzvU41pIA2HUEawpDlgzqbwKjm4I8kM,6852
 apify/_models.py,sha256=EzU-inWeJ7T5HNVYEwnYb79W-q4OAPhtrYctfRYzpTE,7848
@@ -9,7 +9,7 @@ apify/_proxy_configuration.py,sha256=K9V4vG9-bAx7_a4l0zHhfbzvzopJeHek-qUJ05aQ6wI
 apify/_utils.py,sha256=og_zzRXELQmirklJWp1kSV7pwQPFfAE81UO3IZ4xBNs,2414
 apify/log.py,sha256=Ry251sK4qPRGiFGe3DKcOZazg5OzC6RXS546Zzk8H2M,1003
 apify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify/events/__init__.py,sha256=daZzFNJlJFnm0HZZQVeT26pvRWufjHzKZYERANgfX4o,182
+apify/events/__init__.py,sha256=fLNqlsM6AboUQrAxmb-GD1Pw6oDivN_eSAviGJtqc7c,198
 apify/events/_apify_event_manager.py,sha256=yArFrKa4wWDZo32iwaA3F_w36VSJf1Yaj_L1opo8ncU,5917
 apify/events/_types.py,sha256=F0BHgACqnRfmdQ9GUcpnZvPxzw2bdRr8BqbGSA4cHeQ,3050
 apify/events/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -32,21 +32,26 @@ apify/scrapy/middlewares/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3h
 apify/scrapy/pipelines/__init__.py,sha256=GWPeLN_Zwj8vRBWtXW6DaxdB7mvyQ7Jw5Tz1ccgWlZI,119
 apify/scrapy/pipelines/actor_dataset_push.py,sha256=XUUyznQTD-E3wYUUFt2WAOnWhbnRrY0WuedlfYfYhDI,846
 apify/scrapy/pipelines/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify/storage_clients/__init__.py,sha256=9WLAKs2GnnP0yyKR0mc3AfJ1IqXF48V3KPMp6KaB8kU,277
+apify/storage_clients/__init__.py,sha256=JheTvNpVD_luQXC1KTEgtr6yVnuMEC9ajBNLCX3HuSo,358
 apify/storage_clients/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apify/storage_clients/_apify/__init__.py,sha256=mtbVDsxqWL3kx30elnh0kAn2kZ4s3BBsWa15Y5e7RMU,347
-apify/storage_clients/_apify/_dataset_client.py,sha256=8ZQvbtXZm54-V0Ukio0Z4jVI2gGkfqzZ59GlBQJXGUU,11485
-apify/storage_clients/_apify/_key_value_store_client.py,sha256=WbyzDCFmJS2hd_7ddYL3JEO9zvjUAAE1D_F4kohiim4,9455
-apify/storage_clients/_apify/_models.py,sha256=C6FpXswtO6kXE5RUumazm_conzJJS6PrXAGF9XBuDb8,3651
-apify/storage_clients/_apify/_request_queue_client.py,sha256=sMinB02V9236PH7fQTQ0AIwH6oObnZv2ivzKBEgaLOk,31372
-apify/storage_clients/_apify/_storage_client.py,sha256=5me6gHOeNAG3JaHxKRdzsZaa3FsqLDbObjhECGGWrr4,2890
+apify/storage_clients/_apify/_dataset_client.py,sha256=Bb3UwOaFkyuEY7tuBf8K46R4ZP_b1EaAkDOXOqwSoW8,12498
+apify/storage_clients/_apify/_key_value_store_client.py,sha256=42dARbLX2oeOW7uYYKkDyQbEriMuh55Mxh0SqvkOEGg,10529
+apify/storage_clients/_apify/_models.py,sha256=GEaN7Got1zIg42QPH36obHRWRDVNtzOkRuOWYRf9bFU,4572
+apify/storage_clients/_apify/_request_queue_client.py,sha256=QXCLdTBeNW8RKWnxQOE71KOpZ_lqvqisa89eeiWwZ38,14200
+apify/storage_clients/_apify/_request_queue_shared_client.py,sha256=CbvwcXRvfuBoy3wrQEdLX9_vKELPH_WhHQARP14audM,20709
+apify/storage_clients/_apify/_request_queue_single_client.py,sha256=6CRSyWZPbKQJy3i2JBrojVTnhTYIB3gE0CTymYjpkZA,16958
+apify/storage_clients/_apify/_storage_client.py,sha256=hFl_PuX1UgOydBD6pieZ0u2NWbDmZV-i0qygKdsuHt4,4873
+apify/storage_clients/_apify/_utils.py,sha256=ywXoSM69amRokUZcshbAvQLIcSZq4L-bpYIGyeFxCGQ,7696
 apify/storage_clients/_apify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 apify/storage_clients/_file_system/__init__.py,sha256=rDbXatXV9wHKPhKTrXDzWnexhTm7sIJQWucMi-P-SD4,130
-apify/storage_clients/_file_system/_key_value_store_client.py,sha256=DHDv_e0kFwhBCIXUadZAamHhUao3NsSniUEXgnttnVY,1430
-apify/storage_clients/_file_system/_storage_client.py,sha256=UwxuSvhbyQ7zR1db1hTmZ1h38yH7btHNp82X7e8MWWE,1290
+apify/storage_clients/_file_system/_key_value_store_client.py,sha256=gxM3ap67PnY80Rd7P3onPAf2pksYpU0LoAlJdayEMdU,4179
+apify/storage_clients/_file_system/_storage_client.py,sha256=rcwpKYlrWzvlSA2xoxftg-EZAi_iGZ3vOCbu0C5lKDE,1396
+apify/storage_clients/_smart_apify/__init__.py,sha256=614B2AaWY-dx6RQ6mod7VVR8gFh75-_jnq5BeDD7hSc,53
+apify/storage_clients/_smart_apify/_storage_client.py,sha256=GCPmVe_xWAFcO2Cuej4su4i97_d33Q9Ih_Sc5xW2Wa4,4674
 apify/storages/__init__.py,sha256=-9tEYJVabVs_eRVhUehxN58GH0UG8OfuGjGwuDieP2M,122
 apify/storages/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-apify-3.0.0rc1.dist-info/METADATA,sha256=rkqQ4RZixQMHBEeG2weYmjdTWBFP5m_BxTblxEAbyBU,21801
-apify-3.0.0rc1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-apify-3.0.0rc1.dist-info/licenses/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
-apify-3.0.0rc1.dist-info/RECORD,,
+apify-3.0.1.dist-info/METADATA,sha256=EmYGXdZ84rJZkj-0_UWKQXbhWnNpu0sETwnPxQ-Vbc0,22580
+apify-3.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+apify-3.0.1.dist-info/licenses/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
+apify-3.0.1.dist-info/RECORD,,