apify 2.7.2__py3-none-any.whl → 3.0.0__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/__init__.py

@@ -0,0 +1,2 @@
+from ._key_value_store_client import ApifyFileSystemKeyValueStoreClient
+from ._storage_client import ApifyFileSystemStorageClient

apify/storage_clients/_file_system/_key_value_store_client.py

@@ -0,0 +1,57 @@
+import asyncio
+import json
+from pathlib import Path
+
+from typing_extensions import override
+
+from crawlee._consts import METADATA_FILENAME
+from crawlee.storage_clients._file_system import FileSystemKeyValueStoreClient
+
+from apify._configuration import Configuration
+
+
+class ApifyFileSystemKeyValueStoreClient(FileSystemKeyValueStoreClient):
+    """Apify-specific implementation of the `FileSystemKeyValueStoreClient`.
+
+    The only difference is that it overrides the `purge` method to delete all files in the key-value store
+    directory, except for the metadata file and the `INPUT.json` file.
+    """
+
+    @override
+    async def purge(self) -> None:
+        """Purges the key-value store by deleting all its contents.
+
+        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
+
+        # First try to find the alternative format of the input file and process it if it exists.
+        for file_path in self.path_to_kvs.glob('*'):
+            if file_path.name == f'{kvs_input_key}.json':
+                await self._process_input_json(file_path)
+
+        async with self._lock:
+            for file_path in self.path_to_kvs.glob('*'):
+                if file_path.name in {METADATA_FILENAME, kvs_input_key, f'{kvs_input_key}.{METADATA_FILENAME}'}:
+                    continue
+                if file_path.is_file():
+                    await asyncio.to_thread(file_path.unlink, missing_ok=True)
+
+            await self._update_metadata(
+                update_accessed_at=True,
+                update_modified_at=True,
+            )
+
+    async def _process_input_json(self, path: Path) -> None:
+        """Process simple input json file to format expected by the FileSystemKeyValueStoreClient.
+
+        For example: INPUT.json -> INPUT, INPUT.json.metadata
+        """
+        try:
+            f = await asyncio.to_thread(path.open)
+            input_data = json.load(f)
+        finally:
+            f.close()
+        await asyncio.to_thread(path.unlink, missing_ok=True)
+        await self.set_value(key=path.stem, value=input_data)

apify/storage_clients/_file_system/_storage_client.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from typing_extensions import override
+
+from crawlee.configuration import Configuration
+from crawlee.storage_clients import FileSystemStorageClient
+
+from ._key_value_store_client import ApifyFileSystemKeyValueStoreClient
+
+if TYPE_CHECKING:
+    from crawlee.storage_clients._file_system import FileSystemKeyValueStoreClient
+
+
+class ApifyFileSystemStorageClient(FileSystemStorageClient):
+    """Apify-specific implementation of the file system storage client.
+
+    The only difference is that it uses `ApifyFileSystemKeyValueStoreClient` for key-value stores,
+    which overrides the `purge` method to delete all files in the key-value store directory
+    except for the metadata file and the `INPUT.json` file.
+    """
+
+    @override
+    async def create_kvs_client(
+        self,
+        *,
+        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,
+            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/storages/__init__.py

@@ -1,5 +1,3 @@
 from crawlee.storages import Dataset, KeyValueStore, RequestQueue
 
-from ._request_list import RequestList
-
-__all__ = ['Dataset', 'KeyValueStore', 'RequestList', 'RequestQueue']
+__all__ = ['Dataset', 'KeyValueStore', 'RequestQueue']

{apify-2.7.2.dist-info → apify-3.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: apify
-Version: 2.7.2
+Version: 3.0.0
 Summary: Apify SDK for Python
 Project-URL: Apify Homepage, https://apify.com
 Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
@@ -219,27 +219,43 @@ Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Libraries
-Requires-Python: >=3.9
-Requires-Dist: apify-client<2.0.0
-Requires-Dist: apify-shared<2.0.0
-Requires-Dist: crawlee~=0.6.0
+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<2.0.0,>=1.0.0
 Requires-Dist: cryptography>=42.0.0
-Requires-Dist: httpx>=0.27.0
-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
+Requires-Dist: yarl>=1.18.0
 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.0.dist-info/RECORD

@@ -0,0 +1,57 @@
+apify/__init__.py,sha256=HpgKg2FZWJuSPfDygzJ62psylhw4NN4tKFnoYUIhcd4,838
+apify/_actor.py,sha256=DYHoyBAu6hDLs0BcTZL-IQveLK8gPTWvb6AgDnJc3EA,54755
+apify/_charging.py,sha256=KjZ2DnEMS0Tt8ibizmmt0RwBq8FOAsD1z-hKFgdazcY,13143
+apify/_configuration.py,sha256=gq_UfWTgcP1_0kEMLhXVg33SgSxXjShbuzoXyCFfK0w,14682
+apify/_consts.py,sha256=CjhyEJ4Mi0lcIrzfqz8dN7nPJWGjCeBrrXQy1PZ6zRI,440
+apify/_crypto.py,sha256=tqUs13QkemDtGzvU41pIA2HUEawpDlgzqbwKjm4I8kM,6852
+apify/_models.py,sha256=EzU-inWeJ7T5HNVYEwnYb79W-q4OAPhtrYctfRYzpTE,7848
+apify/_proxy_configuration.py,sha256=K9V4vG9-bAx7_a4l0zHhfbzvzopJeHek-qUJ05aQ6wI,13066
+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=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
+apify/request_loaders/__init__.py,sha256=SJqW0FbdZKEtAMB5kBLgqROzh3KmQc2CNEIhJpTGdPQ,356
+apify/request_loaders/_apify_request_list.py,sha256=kurCxX2jAKzHJ5N1Co6KjIgptqgVmjR0WpT8bd6uK9A,6220
+apify/request_loaders/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/__init__.py,sha256=m2a0ts_JY9xJkBy4JU5mV8PJqjA3GGKLXBFu4nl-n-A,1048
+apify/scrapy/_actor_runner.py,sha256=rXWSnlQWGskDUH8PtLCv5SkOIx4AiVa4QbCYeCett5c,938
+apify/scrapy/_async_thread.py,sha256=8xif_fWce7vaMLuDc-XuDzZlHbCI-NY61YXdP2P27QY,4753
+apify/scrapy/_logging_config.py,sha256=KZttIiMXcfu_isYcvXQnWdoYFdYI2wK5AAdbhd57cp4,1819
+apify/scrapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/requests.py,sha256=JNVsITB-4xtT8LnkQc8z_G4OcEE9CmkMUvLGqbva5ZI,6460
+apify/scrapy/scheduler.py,sha256=hvTJ9AxLoifqZi7C8MtLcCP0ujGk4D4dgq4qbCD_zco,6098
+apify/scrapy/utils.py,sha256=Ssfa-P9-g9XYP1suDce6dQ8ta7PfijiPoMl2iplE6Ow,2126
+apify/scrapy/extensions/__init__.py,sha256=cVQ8CCtOsJsRP28YKZWSUsi4FBwxI-yPJRNSXPFSa_o,98
+apify/scrapy/extensions/_httpcache.py,sha256=XIS9vFCcUtdSfeKAKnxRnI9dX_GMmX2Od8OPnOaDhQ0,8870
+apify/scrapy/middlewares/__init__.py,sha256=tfW-d3WFWLeNEjL8fTmon6NwgD-OXx1Bw2fBdU-wPy4,114
+apify/scrapy/middlewares/apify_proxy.py,sha256=CDAOXS3bcVDZHM3B0GvhXbxEikMIadLF_0P73WL_nI4,5550
+apify/scrapy/middlewares/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+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=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=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=fnSJ1EIOPCGfcE6e5S3Tux9VbnMVLCJjugkaQoH_9yo,2267
+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.0.dist-info/METADATA,sha256=DnqOx7gmtjiPYoIcUHCsCDbVr4sOH-3z2nZXiHxMFMo,22580
+apify-3.0.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+apify-3.0.0.dist-info/licenses/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
+apify-3.0.0.dist-info/RECORD,,