apify 1.7.0b1__py3-none-any.whl → 2.2.0b14__py3-none-any.whl

apify/scrapy/scheduler.py

@@ -1,21 +1,28 @@
 from __future__ import annotations
 
 import traceback
+from typing import TYPE_CHECKING
+
+from apify._configuration import Configuration
+from apify.apify_storage_client import ApifyStorageClient
 
 try:
     from scrapy import Spider
     from scrapy.core.scheduler import BaseScheduler
-    from scrapy.http.request import Request  # noqa: TCH002
     from scrapy.utils.reactor import is_asyncio_reactor_installed
+
+    if TYPE_CHECKING:
+        from scrapy.http.request import Request
 except ImportError as exc:
     raise ImportError(
         'To use this module, you need to install the "scrapy" extra. Run "pip install apify[scrapy]".',
     ) from exc
 
-from apify._crypto import crypto_random_object_id
-from apify.actor import Actor
+from crawlee._utils.crypto import crypto_random_object_id
+
+from apify import Actor
 from apify.scrapy.requests import to_apify_request, to_scrapy_request
-from apify.scrapy.utils import nested_event_loop, open_queue_with_custom_client
+from apify.scrapy.utils import nested_event_loop
 from apify.storages import RequestQueue
 
 
@@ -25,7 +32,7 @@ class ApifyScheduler(BaseScheduler):
     This scheduler requires the asyncio Twisted reactor to be installed.
     """
 
-    def __init__(self: ApifyScheduler) -> None:
+    def __init__(self) -> None:
         """Create a new instance."""
         if not is_asyncio_reactor_installed():
             raise ValueError(
@@ -36,7 +43,7 @@ class ApifyScheduler(BaseScheduler):
         self._rq: RequestQueue | None = None
         self.spider: Spider | None = None
 
-    def open(self: ApifyScheduler, spider: Spider) -> None:  # this has to be named "open"
+    def open(self, spider: Spider) -> None:  # this has to be named "open"
         """Open the scheduler.
 
         Args:
@@ -44,13 +51,17 @@ class ApifyScheduler(BaseScheduler):
         """
         self.spider = spider
 
+        async def open_queue() -> RequestQueue:
+            custom_loop_apify_client = ApifyStorageClient(configuration=Configuration.get_global_configuration())
+            return await RequestQueue.open(storage_client=custom_loop_apify_client)
+
         try:
-            self._rq = nested_event_loop.run_until_complete(open_queue_with_custom_client())
+            self._rq = nested_event_loop.run_until_complete(open_queue())
         except BaseException:
             traceback.print_exc()
             raise
 
-    def has_pending_requests(self: ApifyScheduler) -> bool:
+    def has_pending_requests(self) -> bool:
         """Check if the scheduler has any pending requests.
 
         Returns:
@@ -67,7 +78,7 @@ class ApifyScheduler(BaseScheduler):
 
         return not is_finished
 
-    def enqueue_request(self: ApifyScheduler, request: Request) -> bool:
+    def enqueue_request(self, request: Request) -> bool:
         """Add a request to the scheduler.
 
         This could be called from either from a spider or a downloader middleware (e.g. redirect, retry, ...).
@@ -95,20 +106,15 @@ class ApifyScheduler(BaseScheduler):
             raise TypeError('self._rq must be an instance of the RequestQueue class')
 
         try:
-            result = nested_event_loop.run_until_complete(
-                self._rq.add_request(
-                    apify_request,
-                    use_extended_unique_key=True,
-                )
-            )
+            result = nested_event_loop.run_until_complete(self._rq.add_request(apify_request))
         except BaseException:
             traceback.print_exc()
             raise
 
         Actor.log.debug(f'[{call_id}]: rq.add_request.result={result}...')
-        return bool(result['wasAlreadyPresent'])
+        return bool(result.was_already_present)
 
-    def next_request(self: ApifyScheduler) -> Request | None:
+    def next_request(self) -> Request | None:
         """Fetch the next request from the scheduler.
 
         Returns:
@@ -127,7 +133,9 @@ class ApifyScheduler(BaseScheduler):
             traceback.print_exc()
             raise
 
-        Actor.log.debug(f'[{call_id}]: a new apify_request from the scheduler was fetched (apify_request={apify_request})')
+        Actor.log.debug(
+            f'[{call_id}]: a new apify_request from the scheduler was fetched (apify_request={apify_request})'
+        )
 
         if apify_request is None:
             return None
@@ -145,6 +153,7 @@ class ApifyScheduler(BaseScheduler):
 
         scrapy_request = to_scrapy_request(apify_request, spider=self.spider)
         Actor.log.debug(
-            f'[{call_id}]: apify_request was transformed to the scrapy_request which is gonna be returned (scrapy_request={scrapy_request})',
+            f'[{call_id}]: apify_request was transformed to the scrapy_request which is gonna be returned '
+            f'(scrapy_request={scrapy_request})',
         )
         return scrapy_request

apify/scrapy/utils.py

@@ -2,23 +2,28 @@ from __future__ import annotations
 
 import asyncio
 from base64 import b64encode
+from typing import TYPE_CHECKING
 from urllib.parse import unquote
 
+from apify_shared.utils import ignore_docs
+
 try:
-    from scrapy.settings import Settings  # noqa: TCH002
     from scrapy.utils.project import get_project_settings
     from scrapy.utils.python import to_bytes
+
+    if TYPE_CHECKING:
+        from scrapy.settings import Settings
 except ImportError as exc:
     raise ImportError(
-        'To use this module, you need to install the "scrapy" extra. Run "pip install apify[scrapy]".',
+        'To use this module, you need to install the "scrapy" extra. For example, if you use pip, run '
+        '"pip install apify[scrapy]".'
     ) from exc
 
-from apify.actor import Actor
-from apify.storages import RequestQueue, StorageClientManager
 
 nested_event_loop: asyncio.AbstractEventLoop = asyncio.new_event_loop()
 
 
+@ignore_docs
 def get_basic_auth_header(username: str, password: str, auth_encoding: str = 'latin-1') -> bytes:
     """Generate a basic authentication header for the given username and password."""
     string = f'{unquote(username)}:{unquote(password)}'
@@ -26,6 +31,7 @@ def get_basic_auth_header(username: str, password: str, auth_encoding: str = 'la
     return b'Basic ' + b64encode(user_pass)
 
 
+@ignore_docs
 def get_running_event_loop_id() -> int:
     """Get the ID of the currently running event loop.
 
@@ -71,31 +77,3 @@ def apply_apify_settings(*, settings: Settings | None = None, proxy_config: dict
     settings['APIFY_PROXY_SETTINGS'] = proxy_config
 
     return settings
-
-
-async def open_queue_with_custom_client() -> RequestQueue:
-    """Open a Request Queue with custom Apify Client.
-
-    TODO: add support for custom client to Actor.open_request_queue(), so that
-    we don't have to do this hacky workaround
-    """
-    # Create a new Apify Client with its httpx client in the custom event loop
-    custom_loop_apify_client = Actor.new_client()
-
-    # Set the new Apify Client as the default client, back up the old client
-    old_client = Actor.apify_client
-    StorageClientManager.set_cloud_client(custom_loop_apify_client)
-
-    # Create a new Request Queue in the custom event loop,
-    # replace its Apify client with the custom loop's Apify client
-    rq = await Actor.open_request_queue()
-
-    if Actor.config.is_at_home:
-        rq._request_queue_client = custom_loop_apify_client.request_queue(
-            rq._id,
-            client_key=rq._client_key,
-        )
-
-    # Restore the old Apify Client as the default client
-    StorageClientManager.set_cloud_client(old_client)
-    return rq

apify/storages/__init__.py

@@ -1,11 +1,5 @@
-from .dataset import Dataset
-from .key_value_store import KeyValueStore
-from .request_queue import RequestQueue
-from .storage_client_manager import StorageClientManager
+from crawlee.storages import Dataset, KeyValueStore, RequestQueue
 
-__all__ = [
-    'Dataset',
-    'KeyValueStore',
-    'RequestQueue',
-    'StorageClientManager',
-]
+from ._request_list import RequestList
+
+__all__ = ['Dataset', 'KeyValueStore', 'RequestList', 'RequestQueue']

apify/storages/_request_list.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import asyncio
+import re
+from asyncio import Task
+from functools import partial
+from typing import Annotated, Any, Union
+
+from pydantic import BaseModel, Field, TypeAdapter
+
+from crawlee import Request
+from crawlee._types import HttpMethod
+from crawlee.http_clients import BaseHttpClient, HttpxHttpClient
+from crawlee.request_loaders import RequestList as CrawleeRequestList
+
+from apify._utils import docs_group
+
+URL_NO_COMMAS_REGEX = re.compile(
+    r'https?:\/\/(www\.)?([^\W_]|[^\W_][-\w0-9@:%._+~#=]{0,254}[^\W_])\.[a-z]{2,63}(:\d{1,5})?(\/[-\w@:%+.~#?&/=()]*)?'
+)
+
+
+class _RequestDetails(BaseModel):
+    method: HttpMethod = 'GET'
+    payload: str = ''
+    headers: Annotated[dict[str, str], Field(default_factory=dict)] = {}
+    user_data: Annotated[dict[str, str], Field(default_factory=dict, alias='userData')] = {}
+
+
+class _RequestsFromUrlInput(_RequestDetails):
+    requests_from_url: str = Field(alias='requestsFromUrl')
+
+
+class _SimpleUrlInput(_RequestDetails):
+    url: str
+
+
+url_input_adapter = TypeAdapter(list[Union[_RequestsFromUrlInput, _SimpleUrlInput]])
+
+
+@docs_group('Classes')
+class RequestList(CrawleeRequestList):
+    """Extends crawlee RequestList.
+
+    Method open is used to create RequestList from actor's requestListSources input.
+    """
+
+    @staticmethod
+    async def open(
+        name: str | None = None,
+        request_list_sources_input: list[dict[str, Any]] | None = None,
+        http_client: BaseHttpClient | None = None,
+    ) -> RequestList:
+        """Creates RequestList from Actor input requestListSources.
+
+        Args:
+            name: Name of the returned RequestList.
+            request_list_sources_input: List of dicts with either url key or requestsFromUrl key.
+            http_client: Client that will be used to send get request to urls defined by value of requestsFromUrl keys.
+
+        Returns:
+            RequestList created from request_list_sources_input.
+
+        ### Usage
+
+        ```python
+        example_input = [
+            # Gather urls from response body.
+            {'requestsFromUrl': 'https://crawlee.dev/file.txt', 'method': 'GET'},
+            # Directly include this url.
+            {'url': 'https://crawlee.dev', 'method': 'GET'}
+        ]
+        request_list = await RequestList.open(request_list_sources_input=example_input)
+        ```
+        """
+        request_list_sources_input = request_list_sources_input or []
+        return await RequestList._create_request_list(name, request_list_sources_input, http_client)
+
+    @staticmethod
+    async def _create_request_list(
+        name: str | None, request_list_sources_input: list[dict[str, Any]], http_client: BaseHttpClient | None
+    ) -> RequestList:
+        if not http_client:
+            http_client = HttpxHttpClient()
+
+        url_inputs = url_input_adapter.validate_python(request_list_sources_input)
+
+        simple_url_inputs = [url_input for url_input in url_inputs if isinstance(url_input, _SimpleUrlInput)]
+        remote_url_inputs = [url_input for url_input in url_inputs if isinstance(url_input, _RequestsFromUrlInput)]
+
+        simple_url_requests = RequestList._create_requests_from_input(simple_url_inputs)
+        remote_url_requests = await RequestList._fetch_requests_from_url(remote_url_inputs, http_client=http_client)
+
+        return RequestList(name=name, requests=simple_url_requests + remote_url_requests)
+
+    @staticmethod
+    def _create_requests_from_input(simple_url_inputs: list[_SimpleUrlInput]) -> list[Request]:
+        return [
+            Request.from_url(
+                method=request_input.method,
+                url=request_input.url,
+                payload=request_input.payload.encode('utf-8'),
+                headers=request_input.headers,
+                user_data=request_input.user_data,
+            )
+            for request_input in simple_url_inputs
+        ]
+
+    @staticmethod
+    async def _fetch_requests_from_url(
+        remote_url_requests_inputs: list[_RequestsFromUrlInput], http_client: BaseHttpClient
+    ) -> list[Request]:
+        """Crete list of requests from url.
+
+        Send GET requests to urls defined in each requests_from_url of remote_url_requests_inputs. Run extracting
+        callback on each response body and use URL_NO_COMMAS_REGEX regex to find all links. Create list of Requests from
+        collected links and additional inputs stored in other attributes of each remote_url_requests_inputs.
+        """
+        created_requests: list[Request] = []
+
+        def create_requests_from_response(request_input: _RequestsFromUrlInput, task: Task) -> None:
+            """Callback to scrape response body with regexp and create Requests from matches."""
+            matches = re.finditer(URL_NO_COMMAS_REGEX, task.result().read().decode('utf-8'))
+            created_requests.extend(
+                [
+                    Request.from_url(
+                        match.group(0),
+                        method=request_input.method,
+                        payload=request_input.payload.encode('utf-8'),
+                        headers=request_input.headers,
+                        user_data=request_input.user_data,
+                    )
+                    for match in matches
+                ]
+            )
+
+        remote_url_requests = []
+        for remote_url_requests_input in remote_url_requests_inputs:
+            get_response_task = asyncio.create_task(
+                http_client.send_request(
+                    method='GET',
+                    url=remote_url_requests_input.requests_from_url,
+                )
+            )
+
+            get_response_task.add_done_callback(partial(create_requests_from_response, remote_url_requests_input))
+            remote_url_requests.append(get_response_task)
+
+        await asyncio.gather(*remote_url_requests)
+        return created_requests

apify-2.2.0b14.dist-info/METADATA

@@ -0,0 +1,211 @@
+Metadata-Version: 2.3
+Name: apify
+Version: 2.2.0b14
+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: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries
+Provides-Extra: scrapy
+Requires-Dist: apify-client (>=1.8.1)
+Requires-Dist: apify-shared (>=1.2.1)
+Requires-Dist: crawlee (>=0.5.1,<0.6.0)
+Requires-Dist: cryptography (>=42.0.0)
+Requires-Dist: httpx (>=0.27.0)
+Requires-Dist: lazy-object-proxy (>=1.10.0)
+Requires-Dist: more_itertools (>=10.2.0)
+Requires-Dist: scrapy (>=2.11.0) ; extra == "scrapy"
+Requires-Dist: typing-extensions (>=4.1.0)
+Requires-Dist: websockets (>=10.0,<14.0.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.2.0b14.dist-info/RECORD

@@ -0,0 +1,38 @@
+apify/__init__.py,sha256=99ynaDWBLEcCjdLq7R0Exy_iACsXiXoQ8VUZKmbzTeM,550
+apify/_actor.py,sha256=X8UCTYVJmsq0Nus7aru1ayEgrbo8QE__0jKaN8aWMZ0,44313
+apify/_configuration.py,sha256=T3Z_o_W98iSyTbrutfb578yW51aexZ_V0FcLwTxFLjI,10878
+apify/_consts.py,sha256=_Xq4hOfOA1iZ3n1P967YWdyncKivpbX6RTlp_qanUoE,330
+apify/_crypto.py,sha256=e0_aM3l9_5Osk-jszYOOjrAKK60OggSHbiw5c30QnsU,5638
+apify/_models.py,sha256=Btlz-23obKY5tJ75JnUwkVNC2lmU1IEBbdU3HvWaVhg,5748
+apify/_platform_event_manager.py,sha256=44xyV0Lpzf4h4VZ0rkyYg_nhbQkEONNor8_Z9gIKO40,7899
+apify/_proxy_configuration.py,sha256=c-O6_PZ9pUD-i4J0RFEKTtfyJPP2rTRJJA1TH8NVsV8,13189
+apify/_utils.py,sha256=CCLkpAsZKp00ykm88Z_Fbck5PNT0j6mJYOuD0RxzZUs,1620
+apify/apify_storage_client/__init__.py,sha256=-UbR68bFsDR6ln8OFs4t50eqcnY36hujO-SeOt-KmcA,114
+apify/apify_storage_client/_apify_storage_client.py,sha256=0rS75JoRHt7stRYS9-oqm3DmaSIZQN5C11N5MZQUvlA,2616
+apify/apify_storage_client/_dataset_client.py,sha256=UUodnR_MQBg5RkURrfegkGJWR5OmdPPgPfGepvkdQoU,5580
+apify/apify_storage_client/_dataset_collection_client.py,sha256=qCcKZlA0bkO-sL7xED0Yose85NlrRa9AKr4oCSrYX6k,1489
+apify/apify_storage_client/_key_value_store_client.py,sha256=MSuoIeqEHLu92WfUU7kyB3Cc_gKUlm8TghnU3_xkPtE,3363
+apify/apify_storage_client/_key_value_store_collection_client.py,sha256=NxD-3XDJP6JGMDyIa6ib0gl8op7rQjSQ0vlToCiV190,1563
+apify/apify_storage_client/_request_queue_client.py,sha256=n-CR-hA5LM6_8IwiMwQ9tT2juavq7X2zC3ZNlrtv-2s,5156
+apify/apify_storage_client/_request_queue_collection_client.py,sha256=MdzgbQb2D8rHWpUlPCrQSHRlAi0fI0PSZ9bYagr-MhY,1571
+apify/apify_storage_client/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/log.py,sha256=j-E4t-WeA93bc1NCQRG8sTntehQCiiN8ia-MdQe3_Ts,1291
+apify/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/__init__.py,sha256=HE5wCN7-DZKPydLCOvjNyLuL3CvN2fUFweXfrDfe1Ss,348
+apify/scrapy/middlewares/__init__.py,sha256=tfW-d3WFWLeNEjL8fTmon6NwgD-OXx1Bw2fBdU-wPy4,114
+apify/scrapy/middlewares/apify_proxy.py,sha256=9_-hJqTwQ4yVMjvN9zkJ_GXJADzrrYu8QoHZ6IX6fDs,5764
+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=otggoULfUdCqOPJLb9wMROZ9WylnlL-209930tMS2Rg,971
+apify/scrapy/pipelines/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify/scrapy/requests.py,sha256=yZ9hIsz2YyqOoOwzN9F1h76wG4qwawrI6h_6xq0I7Iw,7599
+apify/scrapy/scheduler.py,sha256=03kZxejWWb-TofJ-vpSZuQ28rT-qNjhhpC-QeO2OzoU,5977
+apify/scrapy/utils.py,sha256=758DcHCSAgCTProY0QX74uJ1XrzVsQwvCmFanj2f_3Q,2928
+apify/storages/__init__.py,sha256=FW-z6ubuPnHGM-Wp15T8mR5q6lnpDGrCW-IkgZd5L30,177
+apify/storages/_request_list.py,sha256=-lZJcE5nq69aJhGFJ7Sh2ctqgAWUDyOwYm5_0y1hdAE,5865
+apify/storages/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+apify-2.2.0b14.dist-info/LICENSE,sha256=AsFjHssKjj4LGd2ZCqXn6FBzMqcWdjQre1byPPSypVw,11355
+apify-2.2.0b14.dist-info/METADATA,sha256=vagvl8FfixTKDEiYx3WI7D541NifN21SGjWuFVCuOHE,8714
+apify-2.2.0b14.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+apify-2.2.0b14.dist-info/RECORD,,

{apify-1.7.0b1.dist-info → apify-2.2.0b14.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: poetry-core 2.0.1
 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']