Rename access to request_queue_access

Author: Pijukatel

docs/04_upgrading/upgrading_to_v3.md

@@ -111,6 +111,7 @@ async def main():
 - It is now possible to have full control over which storage clients are used by the `Actor`. To make development of Actors convenient, the `Actor` has two storage clients. One that is used when running on Apify platform or when opening storages with `force_cloud=True` and the other client that is used when running outside the Apify platform. The `Actor` has reasonable defaults and for the majority of use-cases there is no need to change it. However, if you need to use a different storage client, you can set it up before entering `Actor` context through `service_locator`.
 
 **Now (v3.0):**
+
 ```python
 from crawlee import service_locator
 from apify.storage_clients import ApifyStorageClient, ApifyHybridStorageClient, MemoryStorageClient
@@ -120,7 +121,7 @@ from apify import Actor
 async def main():
     service_locator.set_storage_client(
         ApifyHybridStorageClient(
-            cloud_storage_client=ApifyStorageClient(access="single"),
+            cloud_storage_client=ApifyStorageClient(request_queue_access="single"),
             local_storage_client=MemoryStorageClient()
         )
     )
@@ -132,7 +133,7 @@ async def main():
 ## The default use of optimized ApifyRequestQueueClient
 
 - The default client for working with Apify platform based `RequestQueue` is now optimized and simplified client which does significantly lower amount of API calls, but does not support multiple consumers working on the same queue. It is cheaper and faster and is suitable for the majority of the use cases.
-- The full client is still available, but it has to be explicitly requested via `access="shared"` argument when using the `ApifyStorageClient`.
+- The full client is still available, but it has to be explicitly requested via `request_queue_access="shared"` argument when using the `ApifyStorageClient`.
 
 **Now (v3.0):**
 
@@ -141,9 +142,10 @@ from crawlee import service_locator
 from apify.storage_clients import ApifyStorageClient
 from apify import Actor
 
+
 async def main():
-   # Full client that supports multiple consumers of the Apify Request Queue
-    service_locator.set_storage_client(ApifyStorageClient(access="shared"))
+    # Full client that supports multiple consumers of the Apify Request Queue
+    service_locator.set_storage_client(ApifyStorageClient(request_queue_access="shared"))
     async with Actor:
         rq = await Actor.open_request_queue()
 ```

src/apify/storage_clients/_apify/_storage_client.py

@@ -26,16 +26,16 @@
 class ApifyStorageClient(StorageClient):
     """Apify storage client."""
 
-    def __init__(self, *, access: Literal['single', 'shared'] = 'single') -> None:
+    def __init__(self, *, request_queue_access: Literal['single', 'shared'] = 'single') -> None:
         """Initialize the Apify storage client.
 
         Args:
-            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.
+            request_queue_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._access = access
+        self._request_queue_access = request_queue_access
 
     # This class breaches Liskov Substitution Principle. It requires specialized Configuration compared to its parent.
     _lsp_violation_error_message_template = (
@@ -96,7 +96,9 @@ async def create_rq_client(
         configuration = configuration or ApifyConfiguration.get_global_configuration()
         if isinstance(configuration, ApifyConfiguration):
             client: type[ApifyRequestQueueClient] = (
-                ApifyRequestQueueSingleClient if self._access == 'single' else ApifyRequestQueueSharedClient
+                ApifyRequestQueueSingleClient
+                if self._request_queue_access == 'single'
+                else ApifyRequestQueueSharedClient
             )
             return await client.open(id=id, name=name, alias=alias, configuration=configuration)
 

src/apify/storage_clients/_hybrid_apify/_storage_client.py

@@ -43,7 +43,7 @@ def __init__(
             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(access='single')
+        self._cloud_storage_client = cloud_storage_client or ApifyStorageClient(request_queue_access='single')
         self._local_storage_client = local_storage_client or ApifyFileSystemStorageClient()
 
     def _get_suitable_storage_client(self, *, force_cloud: bool = False) -> StorageClient:

tests/integration/conftest.py

@@ -115,7 +115,7 @@ async def request_queue_apify(
     monkeypatch.setenv(ApifyEnvVars.TOKEN, apify_token)
 
     async with Actor:
-        rq = await RequestQueue.open(storage_client=ApifyStorageClient(access=request.param))
+        rq = await RequestQueue.open(storage_client=ApifyStorageClient(request_queue_access=request.param))
         yield rq
         await rq.drop()
 

tests/integration/test_actor_request_queue.py

@@ -33,7 +33,7 @@ async def apify_named_rq(
 
     async with Actor:
         request_queue = await RequestQueue.open(
-            name=request_queue_name, storage_client=ApifyStorageClient(access=request.param)
+            name=request_queue_name, storage_client=ApifyStorageClient(request_queue_access=request.param)
         )
         yield request_queue
         await request_queue.drop()

tests/integration/test_apify_storages.py

@@ -40,7 +40,7 @@ async def test_actor_full_explicit_storage_init(apify_token: str) -> None:
     service_locator.set_storage_client(
         ApifyHybridStorageClient(
             local_storage_client=MemoryStorageClient(),
-            cloud_storage_client=ApifyStorageClient(access='shared'),
+            cloud_storage_client=ApifyStorageClient(request_queue_access='shared'),
         )
     )
     async with Actor():
@@ -55,8 +55,8 @@ async def test_actor_full_explicit_storage_init_same_client(apify_token: str) ->
     service_locator.set_configuration(Configuration(token=apify_token))
     service_locator.set_storage_client(
         ApifyHybridStorageClient(
-            local_storage_client=ApifyStorageClient(access='shared'),
-            cloud_storage_client=ApifyStorageClient(access='shared'),
+            local_storage_client=ApifyStorageClient(request_queue_access='shared'),
+            cloud_storage_client=ApifyStorageClient(request_queue_access='shared'),
         )
     )
     async with Actor():
@@ -69,7 +69,7 @@ async def test_actor_full_explicit_storage_init_same_client(apify_token: str) ->
 
 async def test_actor_partial_explicit_cloud_storage_init(apify_token: str) -> None:
     service_locator.set_configuration(Configuration(token=apify_token))
-    service_locator.set_storage_client(ApifyStorageClient(access='shared'))
+    service_locator.set_storage_client(ApifyStorageClient(request_queue_access='shared'))
     async with Actor():
         # If service locator was already set with ApifyStorageClient, the actor will use it as cloud_storage_client of
         # ApifyHybridStorageClient
@@ -108,7 +108,7 @@ async def main() -> None:
         service_locator.set_storage_client(
             ApifyHybridStorageClient(
                 local_storage_client=MemoryStorageClient(),
-                cloud_storage_client=ApifyStorageClient(access='shared'),
+                cloud_storage_client=ApifyStorageClient(request_queue_access='shared'),
             )
         )
         async with Actor():

tests/integration/test_request_queue.py

@@ -1086,8 +1086,8 @@ 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(access='single'))
-        rq_full = await RequestQueue.open(storage_client=ApifyStorageClient(access='shared'))
+        rq_simple = await RequestQueue.open(storage_client=ApifyStorageClient(request_queue_access='single'))
+        rq_full = await RequestQueue.open(storage_client=ApifyStorageClient(request_queue_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()
@@ -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(access=access))
+        rq = await RequestQueue.open(storage_client=ApifyStorageClient(request_queue_access=access))
         crawler = BasicCrawler(request_manager=rq)
 
         @crawler.router.default_handler