Use single and shared literals and rename the RQ client classes

Author: Pijukatel

src/apify/storage_clients/_apify/_request_queue_client_full.py renamed to src/apify/storage_clients/_apify/_request_queue_shared_client.py

@@ -25,7 +25,7 @@
 logger = getLogger(__name__)
 
 
-class ApifyRequestQueueClientFull(ApifyRequestQueueClient):
+class ApifyRequestQueueSharedClient(ApifyRequestQueueClient):
     """An Apify platform implementation of the request queue client.
 
     This implementation supports multiple producers and multiple consumers scenario.

src/apify/storage_clients/_apify/_request_queue_client_simple.py renamed to src/apify/storage_clients/_apify/_request_queue_single_client.py

@@ -23,7 +23,7 @@
 logger = getLogger(__name__)
 
 
-class ApifyRequestQueueClientSimple(ApifyRequestQueueClient):
+class ApifyRequestQueueSingleClient(ApifyRequestQueueClient):
     """An Apify platform implementation of the request queue client with limited capability.
 
     This client is designed to use as little resources as possible, but has to be used in constrained context.

src/apify/storage_clients/_apify/_storage_client.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from typing_extensions import override
 
 from crawlee.storage_clients._base import StorageClient
 
 from ._dataset_client import ApifyDatasetClient
 from ._key_value_store_client import ApifyKeyValueStoreClient
-from ._request_queue_client_full import ApifyRequestQueueClientFull
-from ._request_queue_client_simple import ApifyRequestQueueClientSimple
+from ._request_queue_shared_client import ApifyRequestQueueSharedClient
+from ._request_queue_single_client import ApifyRequestQueueSingleClient
 from ._utils import hash_api_base_url_and_token
 from apify._configuration import Configuration as ApifyConfiguration
 from apify._utils import docs_group
@@ -26,16 +26,16 @@
 class ApifyStorageClient(StorageClient):
     """Apify storage client."""
 
-    def __init__(self, *, simple_request_queue: bool = True) -> None:
+    def __init__(self, *, access: Literal['single', 'shared'] = 'single') -> None:
         """Initialize the Apify storage client.
 
         Args:
-            simple_request_queue: If True, the `create_rq_client` will always return `ApifyRequestQueueClientSimple`,
-                if false it will return `ApifyRequestQueueClientFull`. Simple client is suitable for single consumer
-                scenarios and makes less API calls. Full client is suitable for multiple consumers scenarios at the
-                cost of higher API usage
+            access: If 'single', the `create_rq_client` will return `ApifyRequestQueueSingleClient`, if 'shared' it
+            will return `ApifyRequestQueueSharedClient`.
+            - 'single' is suitable for single consumer scenarios. It makes less API calls, is cheaper and faster.
+            - 'shared' is suitable for multiple consumers scenarios at the cost of higher API usage.
         """
-        self._simple_request_queue = simple_request_queue
+        self._access = access
 
     # This class breaches Liskov Substitution Principle. It requires specialized Configuration compared to its parent.
     _lsp_violation_error_message_template = (
@@ -96,7 +96,7 @@ async def create_rq_client(
         configuration = configuration or ApifyConfiguration.get_global_configuration()
         if isinstance(configuration, ApifyConfiguration):
             client: type[ApifyRequestQueueClient] = (
-                ApifyRequestQueueClientSimple if self._simple_request_queue else ApifyRequestQueueClientFull
+                ApifyRequestQueueSingleClient if self._access == 'single' else ApifyRequestQueueSharedClient
             )
             return await client.open(id=id, name=name, alias=alias, configuration=configuration)
 

tests/integration/conftest.py

@@ -107,15 +107,15 @@ def apify_client_async(apify_token: str) -> ApifyClientAsync:
     return ApifyClientAsync(apify_token, api_url=api_url)
 
 
-@pytest.fixture(params=[False, True])
+@pytest.fixture(params=[['single', 'shared']])
 async def request_queue_apify(
     apify_token: str, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest
 ) -> AsyncGenerator[RequestQueue]:
     """Create an instance of the Apify request queue on the platform and drop it when the test is finished."""
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_token)
 
     async with Actor:
-        rq = await RequestQueue.open(storage_client=ApifyStorageClient(simple_request_queue=request.param))
+        rq = await RequestQueue.open(storage_client=ApifyStorageClient(access=request.param))
         yield rq
         await rq.drop()
 

tests/integration/test_actor_request_queue.py

@@ -23,7 +23,7 @@
     from .conftest import MakeActorFunction, RunActorFunction
 
 
-@pytest.fixture(params=[False, True])
+@pytest.fixture(params=['single', 'shared'])
 async def apify_named_rq(
     apify_client_async: ApifyClientAsync, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest
 ) -> AsyncGenerator[RequestQueue]:
@@ -33,7 +33,7 @@ async def apify_named_rq(
 
     async with Actor:
         request_queue = await RequestQueue.open(
-            name=request_queue_name, storage_client=ApifyStorageClient(simple_request_queue=request.param)
+            name=request_queue_name, storage_client=ApifyStorageClient(access=request.param)
         )
         yield request_queue
         await request_queue.drop()

tests/integration/test_request_queue.py

@@ -2,7 +2,7 @@
 
 import asyncio
 from datetime import datetime, timezone
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING, Literal, cast
 
 import pytest
 
@@ -1086,22 +1086,22 @@ async def test_request_queue_simple_and_full_at_the_same_time(
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_token)
 
     async with Actor:
-        rq_simple = await RequestQueue.open(storage_client=ApifyStorageClient(simple_request_queue=True))
-        rq_full = await RequestQueue.open(storage_client=ApifyStorageClient(simple_request_queue=False))
+        rq_simple = await RequestQueue.open(storage_client=ApifyStorageClient(access='single'))
+        rq_full = await RequestQueue.open(storage_client=ApifyStorageClient(access='shared'))
         # Opening same queue again with different ApifyStorageClient will resolve to the first client used.
         assert rq_simple is rq_full
         await rq_simple.drop()
 
 
 @pytest.mark.parametrize(
-    ('simple_request_queue', 'expected_write_count_per_request'),
-    [pytest.param(True, 2, id='Simple rq client'), pytest.param(False, 3, id='Full rq client')],
+    ('access', 'expected_write_count_per_request'),
+    [pytest.param('single', 2, id='Simple rq client'), pytest.param('shared', 3, id='Full rq client')],
 )
 async def test_crawler_run_request_queue_variant_stats(
     *,
     apify_token: str,
     monkeypatch: pytest.MonkeyPatch,
-    simple_request_queue: bool,
+    access: Literal['single', 'shared'],
     expected_write_count_per_request: int,
 ) -> None:
     """Check the main difference in the simple vs full request queue client - writeCount per request.
@@ -1112,7 +1112,7 @@ async def test_crawler_run_request_queue_variant_stats(
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_token)
     async with Actor:
         requests = 5
-        rq = await RequestQueue.open(storage_client=ApifyStorageClient(simple_request_queue=simple_request_queue))
+        rq = await RequestQueue.open(storage_client=ApifyStorageClient(access=access))
         crawler = BasicCrawler(request_manager=rq)
 
         @crawler.router.default_handler