apify 1.7.3b4__py3-none-any.whl → 2.0.0__py3-none-any.whl

apify-2.0.0.dist-info/METADATA

@@ -0,0 +1,209 @@
+Metadata-Version: 2.1
+Name: apify
+Version: 2.0.0
+Summary: Apify SDK for Python
+License: Apache-2.0
+Keywords: apify,sdk,automation,chrome,crawlee,crawler,headless,scraper,scraping
+Author: Apify Technologies s.r.o.
+Author-email: support@apify.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries
+Provides-Extra: scrapy
+Requires-Dist: apify-client (>=1.7.1)
+Requires-Dist: apify-shared (>=1.1.2)
+Requires-Dist: crawlee (>=0.3.5)
+Requires-Dist: cryptography (>=42.0.0)
+Requires-Dist: httpx (>=0.27.0)
+Requires-Dist: lazy-object-proxy (>=1.10.0)
+Requires-Dist: scrapy (>=2.11.0) ; extra == "scrapy"
+Requires-Dist: typing-extensions (>=4.1.0)
+Requires-Dist: websockets (>=10.0)
+Project-URL: Apify Homepage, https://apify.com
+Project-URL: Changelog, https://docs.apify.com/sdk/python/docs/changelog
+Project-URL: Documentation, https://docs.apify.com/sdk/python/
+Project-URL: Homepage, https://docs.apify.com/sdk/python/
+Project-URL: Issue Tracker, https://github.com/apify/apify-sdk-python/issues
+Project-URL: Repository, https://github.com/apify/apify-sdk-python
+Description-Content-Type: text/markdown
+
+# Apify SDK for Python
+
+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
+event handling.
+
+If you just need to access the [Apify API](https://docs.apify.com/api/v2) from your Python applications,
+check out the [Apify Client for Python](https://docs.apify.com/api/client/python) instead.
+
+## Installation
+
+The Apify SDK for Python is available on PyPI as the `apify` package.
+For default installation, using Pip, run the following:
+
+```bash
+pip install apify
+```
+
+For users interested in integrating Apify with Scrapy, we provide a package extra called `scrapy`.
+To install Apify with the `scrapy` extra, use the following command:
+
+```bash
+pip install apify[scrapy]
+```
+
+## Documentation
+
+For usage instructions, check the documentation on [Apify Docs](https://docs.apify.com/sdk/python/).
+
+## Examples
+
+Below are few examples demonstrating how to use the Apify SDK with some web scraping-related libraries.
+
+### Apify SDK with HTTPX and BeautifulSoup
+
+This example illustrates how to integrate the Apify SDK with [HTTPX](https://www.python-httpx.org/) and [BeautifulSoup](https://pypi.org/project/beautifulsoup4/) to scrape data from web pages.
+
+```python
+from apify import Actor
+from bs4 import BeautifulSoup
+from httpx import AsyncClient
+
+
+async def main() -> None:
+    async with Actor:
+        # Retrieve the Actor input, and use default values if not provided.
+        actor_input = await Actor.get_input() or {}
+        start_urls = actor_input.get('start_urls', [{'url': 'https://apify.com'}])
+
+        # Open the default request queue for handling URLs to be processed.
+        request_queue = await Actor.open_request_queue()
+
+        # Enqueue the start URLs.
+        for start_url in start_urls:
+            url = start_url.get('url')
+            await request_queue.add_request(url)
+
+        # Process the URLs from the request queue.
+        while request := await request_queue.fetch_next_request():
+            Actor.log.info(f'Scraping {request.url} ...')
+
+            # Fetch the HTTP response from the specified URL using HTTPX.
+            async with AsyncClient() as client:
+                response = await client.get(request.url)
+
+            # Parse the HTML content using Beautiful Soup.
+            soup = BeautifulSoup(response.content, 'html.parser')
+
+            # Extract the desired data.
+            data = {
+                'url': actor_input['url'],
+                'title': soup.title.string,
+                'h1s': [h1.text for h1 in soup.find_all('h1')],
+                'h2s': [h2.text for h2 in soup.find_all('h2')],
+                'h3s': [h3.text for h3 in soup.find_all('h3')],
+            }
+
+            # Store the extracted data to the default dataset.
+            await Actor.push_data(data)
+```
+
+### Apify SDK with PlaywrightCrawler from Crawlee
+
+This example demonstrates how to use the Apify SDK alongside `PlaywrightCrawler` from [Crawlee](https://crawlee.dev/python) to perform web scraping.
+
+```python
+from apify import Actor, Request
+from crawlee.playwright_crawler import PlaywrightCrawler, PlaywrightCrawlingContext
+
+
+async def main() -> None:
+    async with Actor:
+        # Retrieve the Actor input, and use default values if not provided.
+        actor_input = await Actor.get_input() or {}
+        start_urls = [url.get('url') for url in actor_input.get('start_urls', [{'url': 'https://apify.com'}])]
+
+        # Exit if no start URLs are provided.
+        if not start_urls:
+            Actor.log.info('No start URLs specified in Actor input, exiting...')
+            await Actor.exit()
+
+        # Create a crawler.
+        crawler = PlaywrightCrawler(
+            # Limit the crawl to max requests. Remove or increase it for crawling all links.
+            max_requests_per_crawl=50,
+            headless=True,
+        )
+
+        # Define a request handler, which will be called for every request.
+        @crawler.router.default_handler
+        async def request_handler(context: PlaywrightCrawlingContext) -> None:
+            url = context.request.url
+            Actor.log.info(f'Scraping {url}...')
+
+            # Extract the desired data.
+            data = {
+                'url': context.request.url,
+                'title': await context.page.title(),
+                'h1s': [await h1.text_content() for h1 in await context.page.locator('h1').all()],
+                'h2s': [await h2.text_content() for h2 in await context.page.locator('h2').all()],
+                'h3s': [await h3.text_content() for h3 in await context.page.locator('h3').all()],
+            }
+
+            # Store the extracted data to the default dataset.
+            await context.push_data(data)
+
+            # Enqueue additional links found on the current page.
+            await context.enqueue_links()
+
+        # Run the crawler with the starting URLs.
+        await crawler.run(start_urls)
+```
+
+## What are Actors?
+
+Actors are serverless cloud programs that can do almost anything a human can do in a web browser.
+They can do anything from small tasks such as filling in forms or unsubscribing from online services,
+all the way up to scraping and processing vast numbers of web pages.
+
+They can be run either locally, or on the [Apify platform](https://docs.apify.com/platform/),
+where you can run them at scale, monitor them, schedule them, or publish and monetize them.
+
+If you're new to Apify, learn [what is Apify](https://docs.apify.com/platform/about)
+in the Apify platform documentation.
+
+## Creating Actors
+
+To create and run Actors through Apify Console,
+see the [Console documentation](https://docs.apify.com/academy/getting-started/creating-actors#choose-your-template).
+
+To create and run Python Actors locally, check the documentation for
+[how to create and run Python Actors locally](https://docs.apify.com/sdk/python/docs/overview/running-locally).
+
+## Guides
+
+To see how you can use the Apify SDK with other popular libraries used for web scraping,
+check out our guides for using
+[Requests and HTTPX](https://docs.apify.com/sdk/python/docs/guides/requests-and-httpx),
+[Beautiful Soup](https://docs.apify.com/sdk/python/docs/guides/beautiful-soup),
+[Playwright](https://docs.apify.com/sdk/python/docs/guides/playwright),
+[Selenium](https://docs.apify.com/sdk/python/docs/guides/selenium),
+or [Scrapy](https://docs.apify.com/sdk/python/docs/guides/scrapy).
+
+## Usage concepts
+
+To learn more about the features of the Apify SDK and how to use them,
+check out the Usage Concepts section in the sidebar,
+particularly the guides for the [Actor lifecycle](https://docs.apify.com/sdk/python/docs/concepts/actor-lifecycle),
+[working with storages](https://docs.apify.com/sdk/python/docs/concepts/storages),
+[handling Actor events](https://docs.apify.com/sdk/python/docs/concepts/actor-events)
+or [how to use proxies](https://docs.apify.com/sdk/python/docs/concepts/proxy-management).
+

apify-2.0.0.dist-info/RECORD

@@ -0,0 +1,37 @@
+apify/__init__.py,sha256=ikoi2EpDYl6y-XSVtlU8UsdQdMEyOiIJCRRAaZFDOP8,550
+apify/_actor.py,sha256=oPgQ3rxxIEzVcZ9XtI3lf1a_6gwIMgxihNuYGjJpGww,41816
+apify/_configuration.py,sha256=gf7YOun32Whc9DamhoWDLmcUeNwtWVmmBPrl4oq6s4I,8997
+apify/_consts.py,sha256=_Xq4hOfOA1iZ3n1P967YWdyncKivpbX6RTlp_qanUoE,330
+apify/_crypto.py,sha256=b4Czs1NLPkaNzkPjovObjSIbsKnRrgtBkM9JvOysUMA,5612
+apify/_models.py,sha256=oYlTEr-DyQAE-V2rrYD5PhUxTXVPdAig7QV-u6CJw3E,5571
+apify/_platform_event_manager.py,sha256=h5fBmXtKD4t-yCdOSiLM1-DnCrIbGEmYmz2mOU3A8bA,7627
+apify/_proxy_configuration.py,sha256=VdKh_AyCwaCUlpCyaCe30L2S9OZ-vL1SN1g8oLwSeYA,13074
+apify/_utils.py,sha256=x4lnR9RNulySiEQTft-GeQqUcJsRr0k8p0Sv9NTeWFg,638
+apify/apify_storage_client/__init__.py,sha256=-UbR68bFsDR6ln8OFs4t50eqcnY36hujO-SeOt-KmcA,114
+apify/apify_storage_client/_apify_storage_client.py,sha256=xi4OFchxhe-1-sykanH6Zcya4OcBhn2uf7OQ1pV4Ins,2338
+apify/apify_storage_client/_dataset_client.py,sha256=j9seF2OKvbSMD9R9XF9fpa1vtr_1w4JcRV--WCmvU4E,5501
+apify/apify_storage_client/_dataset_collection_client.py,sha256=fkYvYGQCigHD2CDzpWk0swNAkfvAinAhMGpYqllle3E,1445
+apify/apify_storage_client/_key_value_store_client.py,sha256=uyeQgb75sGFsqIS4sq4hEZ3QP81COLfS3tmTqHc0tso,3340
+apify/apify_storage_client/_key_value_store_collection_client.py,sha256=vCtMTI-jx89Qp5WHILDNkCthwLuv0MAwm1J_5E4aypU,1519
+apify/apify_storage_client/_request_queue_client.py,sha256=P8ws8jEzi2PWpp-cvYfV7kwuKbgH813BpNQ_wMSVtTA,6278
+apify/apify_storage_client/_request_queue_collection_client.py,sha256=NnO73UJ9ZrjV8xoudo30wfaM-SojRkG0guhxDyB-K1g,1527
+apify/apify_storage_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/log.py,sha256=pX6ppIvds8OKqjFpIcshqG4zp_5DiOUU31ksyfSExto,1392
+apify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/__init__.py,sha256=qDPV_zTRFaUqoFOyS5g4uBfz-UCkmWYJ82VXQ_3Cw6k,348
+apify/scrapy/middlewares/__init__.py,sha256=tfW-d3WFWLeNEjL8fTmon6NwgD-OXx1Bw2fBdU-wPy4,114
+apify/scrapy/middlewares/apify_proxy.py,sha256=_1WO7NKHxIcPf8mSNjsqANTEsx7ygMTuRQW9fbwKMO8,5837
+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=QERmmExQOGIKQ70-p-lCj5qyE-c-fnYplEqd4mgaB1Q,953
+apify/scrapy/pipelines/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/requests.py,sha256=pmm2M-cwrTXyI3t1nRBo9pS6nHfc4zkzS25-NXxzd9I,7637
+apify/scrapy/scheduler.py,sha256=AAIKY5i1QxkC1mtmix6n3M2eQaOw-d1T56Noue9xToc,6013
+apify/scrapy/utils.py,sha256=tz_Y8CTqe6KbyMMhLF3m7qqR46jtNH5U7Ty7e19roPU,2814
+apify/storages/__init__.py,sha256=-9tEYJVabVs_eRVhUehxN58GH0UG8OfuGjGwuDieP2M,122
+apify/storages/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify-2.0.0.dist-info/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
+apify-2.0.0.dist-info/METADATA,sha256=DhojQDiiwKEwS7VcAufA7ERVHYHKk5mqHFtddWXL4Qk,8604
+apify-2.0.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+apify-2.0.0.dist-info/RECORD,,

{apify-1.7.3b4.dist-info → apify-2.0.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: setuptools (70.3.0)
+Generator: poetry-core 1.9.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

apify/_memory_storage/__init__.py

@@ -1,3 +0,0 @@
-from .memory_storage_client import MemoryStorageClient
-
-__all__ = ['MemoryStorageClient']

apify/_memory_storage/file_storage_utils.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-import os
-
-import aiofiles
-from aiofiles.os import makedirs
-from apify_shared.utils import json_dumps
-
-from apify._utils import force_remove
-
-
-async def update_metadata(*, data: dict, entity_directory: str, write_metadata: bool) -> None:
-    # Skip writing the actual metadata file. This is done after ensuring the directory exists so we have the directory present
-    if not write_metadata:
-        return
-
-    # Ensure the directory for the entity exists
-    await makedirs(entity_directory, exist_ok=True)
-
-    # Write the metadata to the file
-    file_path = os.path.join(entity_directory, '__metadata__.json')
-    async with aiofiles.open(file_path, mode='wb') as f:
-        await f.write(json_dumps(data).encode('utf-8'))
-
-
-async def _update_dataset_items(
-    *,
-    data: list[tuple[str, dict]],
-    entity_directory: str,
-    persist_storage: bool,
-) -> None:
-    # Skip writing files to the disk if the client has the option set to false
-    if not persist_storage:
-        return
-
-    # Ensure the directory for the entity exists
-    await makedirs(entity_directory, exist_ok=True)
-
-    # Save all the new items to the disk
-    for idx, item in data:
-        file_path = os.path.join(entity_directory, f'{idx}.json')
-        async with aiofiles.open(file_path, mode='wb') as f:
-            await f.write(json_dumps(item).encode('utf-8'))
-
-
-async def update_request_queue_item(
-    *,
-    request_id: str,
-    request: dict,
-    entity_directory: str,
-    persist_storage: bool,
-) -> None:
-    # Skip writing files to the disk if the client has the option set to false
-    if not persist_storage:
-        return
-
-    # Ensure the directory for the entity exists
-    await makedirs(entity_directory, exist_ok=True)
-
-    # Write the request to the file
-    file_path = os.path.join(entity_directory, f'{request_id}.json')
-    async with aiofiles.open(file_path, mode='wb') as f:
-        await f.write(json_dumps(request).encode('utf-8'))
-
-
-async def delete_request(*, request_id: str, entity_directory: str) -> None:
-    # Ensure the directory for the entity exists
-    await makedirs(entity_directory, exist_ok=True)
-
-    file_path = os.path.join(entity_directory, f'{request_id}.json')
-    await force_remove(file_path)

apify/_memory_storage/memory_storage_client.py

@@ -1,219 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import contextlib
-import os
-from pathlib import Path
-
-import aioshutil
-from aiofiles import ospath
-from aiofiles.os import rename, scandir
-from apify_shared.consts import ApifyEnvVars
-from apify_shared.utils import ignore_docs
-
-from apify._memory_storage.resource_clients.dataset import DatasetClient
-from apify._memory_storage.resource_clients.dataset_collection import DatasetCollectionClient
-from apify._memory_storage.resource_clients.key_value_store import KeyValueStoreClient
-from apify._memory_storage.resource_clients.key_value_store_collection import KeyValueStoreCollectionClient
-from apify._memory_storage.resource_clients.request_queue import RequestQueueClient
-from apify._memory_storage.resource_clients.request_queue_collection import RequestQueueCollectionClient
-from apify._utils import maybe_parse_bool
-
-"""
-Memory storage emulates data storages that are available on the Apify platform.
-Specifically, it emulates clients for datasets, key-value stores and request queues.
-The data are held in-memory and persisted locally if `persist_storage` is True.
-The metadata of the storages is also persisted if `write_metadata` is True.
-"""
-
-
-@ignore_docs
-class MemoryStorageClient:
-    """Class representing an in-memory storage."""
-
-    _local_data_directory: str
-    _datasets_directory: str
-    _key_value_stores_directory: str
-    _request_queues_directory: str
-    _write_metadata: bool
-    _persist_storage: bool
-    _datasets_handled: list[DatasetClient]
-    _key_value_stores_handled: list[KeyValueStoreClient]
-    _request_queues_handled: list[RequestQueueClient]
-
-    _purged_on_start: bool = False
-    _purge_lock: asyncio.Lock
-
-    """Indicates whether a purge was already performed on this instance"""
-
-    def __init__(
-        self: MemoryStorageClient,
-        *,
-        local_data_directory: str | None = None,
-        write_metadata: bool | None = None,
-        persist_storage: bool | None = None,
-    ) -> None:
-        """Initialize the MemoryStorageClient.
-
-        Args:
-            local_data_directory (str, optional): A local directory where all data will be persisted
-            persist_storage (bool, optional): Whether to persist the data to the `local_data_directory` or just keep them in memory
-            write_metadata (bool, optional): Whether to persist metadata of the storages as well
-        """
-        self._local_data_directory = local_data_directory or os.getenv(ApifyEnvVars.LOCAL_STORAGE_DIR) or './storage'
-        self._datasets_directory = os.path.join(self._local_data_directory, 'datasets')
-        self._key_value_stores_directory = os.path.join(self._local_data_directory, 'key_value_stores')
-        self._request_queues_directory = os.path.join(self._local_data_directory, 'request_queues')
-        self._write_metadata = write_metadata if write_metadata is not None else '*' in os.getenv('DEBUG', '')
-        self._persist_storage = persist_storage if persist_storage is not None else maybe_parse_bool(os.getenv(ApifyEnvVars.PERSIST_STORAGE, 'true'))
-        self._datasets_handled = []
-        self._key_value_stores_handled = []
-        self._request_queues_handled = []
-        self._purge_lock = asyncio.Lock()
-
-    def datasets(self: MemoryStorageClient) -> DatasetCollectionClient:
-        """Retrieve the sub-client for manipulating datasets."""
-        return DatasetCollectionClient(base_storage_directory=self._datasets_directory, memory_storage_client=self)
-
-    def dataset(self: MemoryStorageClient, dataset_id: str) -> DatasetClient:
-        """Retrieve the sub-client for manipulating a single dataset.
-
-        Args:
-            dataset_id (str): ID of the dataset to be manipulated
-        """
-        return DatasetClient(base_storage_directory=self._datasets_directory, memory_storage_client=self, id=dataset_id)
-
-    def key_value_stores(self: MemoryStorageClient) -> KeyValueStoreCollectionClient:
-        """Retrieve the sub-client for manipulating key-value stores."""
-        return KeyValueStoreCollectionClient(base_storage_directory=self._key_value_stores_directory, memory_storage_client=self)
-
-    def key_value_store(self: MemoryStorageClient, key_value_store_id: str) -> KeyValueStoreClient:
-        """Retrieve the sub-client for manipulating a single key-value store.
-
-        Args:
-            key_value_store_id (str): ID of the key-value store to be manipulated
-        """
-        return KeyValueStoreClient(base_storage_directory=self._key_value_stores_directory, memory_storage_client=self, id=key_value_store_id)
-
-    def request_queues(self: MemoryStorageClient) -> RequestQueueCollectionClient:
-        """Retrieve the sub-client for manipulating request queues."""
-        return RequestQueueCollectionClient(base_storage_directory=self._request_queues_directory, memory_storage_client=self)
-
-    def request_queue(
-        self: MemoryStorageClient,
-        request_queue_id: str,
-        *,
-        client_key: str | None = None,  # noqa: ARG002
-    ) -> RequestQueueClient:
-        """Retrieve the sub-client for manipulating a single request queue.
-
-        Args:
-            request_queue_id (str): ID of the request queue to be manipulated
-            client_key (str): A unique identifier of the client accessing the request queue
-        """
-        return RequestQueueClient(base_storage_directory=self._request_queues_directory, memory_storage_client=self, id=request_queue_id)
-
-    async def _purge_on_start(self: MemoryStorageClient) -> None:
-        # Optimistic, non-blocking check
-        if self._purged_on_start is True:
-            return
-
-        async with self._purge_lock:
-            # Another check under the lock just to be sure
-            if self._purged_on_start is True:
-                return  # type: ignore[unreachable] # Mypy doesn't understand that the _purged_on_start can change while we're getting the async lock
-
-            await self._purge()
-            self._purged_on_start = True
-
-    async def _purge(self: MemoryStorageClient) -> None:
-        """Clean up the default storage directories before the run starts.
-
-        Specifically, `purge` cleans up:
-         - local directory containing the default dataset;
-         - all records from the default key-value store in the local directory, except for the "INPUT" key;
-         - local directory containing the default request queue.
-        """
-        # Key-value stores
-        if await ospath.exists(self._key_value_stores_directory):
-            key_value_store_folders = await scandir(self._key_value_stores_directory)
-            for key_value_store_folder in key_value_store_folders:
-                if key_value_store_folder.name.startswith('__APIFY_TEMPORARY') or key_value_store_folder.name.startswith('__OLD'):
-                    await self._batch_remove_files(key_value_store_folder.path)
-                elif key_value_store_folder.name == 'default':
-                    await self._handle_default_key_value_store(key_value_store_folder.path)
-
-        # Datasets
-        if await ospath.exists(self._datasets_directory):
-            dataset_folders = await scandir(self._datasets_directory)
-            for dataset_folder in dataset_folders:
-                if dataset_folder.name == 'default' or dataset_folder.name.startswith('__APIFY_TEMPORARY'):
-                    await self._batch_remove_files(dataset_folder.path)
-        # Request queues
-        if await ospath.exists(self._request_queues_directory):
-            request_queue_folders = await scandir(self._request_queues_directory)
-            for request_queue_folder in request_queue_folders:
-                if request_queue_folder.name == 'default' or request_queue_folder.name.startswith('__APIFY_TEMPORARY'):
-                    await self._batch_remove_files(request_queue_folder.path)
-
-    async def _handle_default_key_value_store(self: MemoryStorageClient, folder: str) -> None:
-        """Remove everything from the default key-value store folder except `possible_input_keys`."""
-        folder_exists = await ospath.exists(folder)
-        temporary_path = os.path.normpath(os.path.join(folder, '../__APIFY_MIGRATING_KEY_VALUE_STORE__'))
-
-        # For optimization, we want to only attempt to copy a few files from the default key-value store
-        possible_input_keys = [
-            'INPUT',
-            'INPUT.json',
-            'INPUT.bin',
-            'INPUT.txt',
-        ]
-
-        if folder_exists:
-            # Create a temporary folder to save important files in
-            Path(temporary_path).mkdir(parents=True, exist_ok=True)
-
-            # Go through each file and save the ones that are important
-            for entity in possible_input_keys:
-                original_file_path = os.path.join(folder, entity)
-                temp_file_path = os.path.join(temporary_path, entity)
-                with contextlib.suppress(Exception):
-                    await rename(original_file_path, temp_file_path)
-
-            # Remove the original folder and all its content
-            counter = 0
-            temp_path_for_old_folder = os.path.normpath(os.path.join(folder, f'../__OLD_DEFAULT_{counter}__'))
-            done = False
-            try:
-                while not done:
-                    await rename(folder, temp_path_for_old_folder)
-                    done = True
-            except Exception:
-                counter += 1
-                temp_path_for_old_folder = os.path.normpath(os.path.join(folder, f'../__OLD_DEFAULT_{counter}__'))
-
-            # Replace the temporary folder with the original folder
-            await rename(temporary_path, folder)
-
-            # Remove the old folder
-            await self._batch_remove_files(temp_path_for_old_folder)
-
-    async def _batch_remove_files(self: MemoryStorageClient, folder: str, counter: int = 0) -> None:
-        folder_exists = await ospath.exists(folder)
-
-        if folder_exists:
-            temporary_folder = (
-                folder
-                if os.path.basename(folder).startswith('__APIFY_TEMPORARY_')
-                else os.path.normpath(os.path.join(folder, f'../__APIFY_TEMPORARY_{counter}__'))
-            )
-
-            try:
-                # Rename the old folder to the new one to allow background deletions
-                await rename(folder, temporary_folder)
-            except Exception:
-                # Folder exists already, try again with an incremented counter
-                return await self._batch_remove_files(folder, counter + 1)
-
-            await aioshutil.rmtree(temporary_folder, ignore_errors=True)
-        return None

apify/_memory_storage/resource_clients/__init__.py

@@ -1,19 +0,0 @@
-from .base_resource_client import BaseResourceClient
-from .base_resource_collection_client import BaseResourceCollectionClient
-from .dataset import DatasetClient
-from .dataset_collection import DatasetCollectionClient
-from .key_value_store import KeyValueStoreClient
-from .key_value_store_collection import KeyValueStoreCollectionClient
-from .request_queue import RequestQueueClient
-from .request_queue_collection import RequestQueueCollectionClient
-
-__all__ = [
-    'BaseResourceClient',
-    'BaseResourceCollectionClient',
-    'DatasetClient',
-    'DatasetCollectionClient',
-    'KeyValueStoreClient',
-    'KeyValueStoreCollectionClient',
-    'RequestQueueClient',
-    'RequestQueueCollectionClient',
-]