Fix type issues, prepare for tests. Merge first

Author: Pijukatel

src/apify/_actor.py

@@ -207,8 +207,7 @@ async def __aenter__(self) -> Self:
             await self.open_key_value_store()
 
         # Load non-default aliased storages from configuration
-        self.log.warning('\n'.join(f'{k}={v}' for k, v in os.environ.items()))
-        await AliasResolver.register_aliases(configuration=self._configuration)
+        #await AliasResolver.register_aliases(configuration=self.configuration)
         return self
 
     async def __aexit__(

src/apify/_configuration.py

@@ -1,13 +1,14 @@
 from __future__ import annotations
 
+import dataclasses
 import json
 from datetime import datetime, timedelta
 from decimal import Decimal
 from logging import getLogger
 from pathlib import Path
-from typing import Annotated, Any, Required, TypedDict
+from typing import Annotated, Any
 
-from pydantic import AliasChoices, BaseModel, BeforeValidator, Field, field_validator, model_validator
+from pydantic import AliasChoices, BeforeValidator, Field, model_validator
 from typing_extensions import Self, deprecated
 
 from crawlee import service_locator
@@ -34,11 +35,26 @@ def _transform_to_list(value: Any) -> list[str] | None:
     return value if isinstance(value, list) else str(value).split(',')
 
 
-class ActorStorageIds(TypedDict):
+@dataclasses.dataclass
+class ActorStorages:
     """Storage IDs for different storage types used by an Actor."""
-    keyValueStores: dict[str, str]
+
+    key_value_stores: dict[str, str]
     datasets: dict[str, str]
-    requestQueues: dict[str, str]
+    request_queues: dict[str, str]
+
+
+def _load_storage_keys(data: None | str | dict) -> ActorStorages | None:
+    """Load storage keys from environment."""
+    if data is None:
+        return None
+
+    storage_mapping = data if isinstance(data, dict) else json.loads(data)
+    return ActorStorages(
+        key_value_stores=storage_mapping.get('keyValueStores', {}),
+        datasets=storage_mapping.get('datasets', {}),
+        request_queues=storage_mapping.get('requestQueues', {}),
+    )
 
 
 @docs_group('Configuration')
@@ -454,12 +470,12 @@ class Configuration(CrawleeConfiguration):
     ] = None
 
     actor_storages: Annotated[
-        ActorStorageIds | None,
+        ActorStorages | None,
         Field(
             alias='actor_storages_json',
             description='Storage IDs for the actor',
         ),
-        BeforeValidator(lambda data: json.loads(data) if isinstance(data, str) else data or None),
+        BeforeValidator(_load_storage_keys),
     ] = None
 
     @model_validator(mode='after')

src/apify/storage_clients/_apify/_alias_resolving.py

@@ -263,38 +263,40 @@ async def _get_default_kvs_client(configuration: Configuration) -> KeyValueStore
 
         return apify_client_async.key_value_store(key_value_store_id=configuration.default_key_value_store_id)
 
-
     @classmethod
     async def register_aliases(cls, configuration: Configuration) -> None:
-        """Load alias mapping from dictionary to the default kvs."""
-        def convert_name(name: str):
-            """Convert from mapping name to storage type name used in the alias mapping."""
-            return {"datasets": "Dataset", "keyValueStores": "KeyValueStore", "requestQueues": "RequestQueue"}[name]
-
+        """Load any alias mapping from configuration to the default kvs."""
+        if configuration.actor_storages is None:
+            return
         configuration_mapping = {}
 
-        if configuration.default_dataset_id != configuration.actor_storages["datasets"].get("default", configuration.default_dataset_id):
-            raise RuntimeError(
-                f"Conflicting default dataset ids: {configuration.default_dataset_id=},"
-                f" {configuration.actor_storages['datasets'].get('default')=}")
+        if configuration.default_dataset_id != configuration.actor_storages.datasets.get(
+            'default'):
+            logger.warning(
+                f'Conflicting default dataset ids: {configuration.default_dataset_id=},'
+                f" {configuration.actor_storages.datasets.get('default')=}"
+            )
 
-        for config_storage_type, mapping in configuration.actor_storages.items():
+        for mapping, storage_type in (
+            (configuration.actor_storages.key_value_stores, 'KeyValueStore'),
+            (configuration.actor_storages.datasets, 'Dataset'),
+            (configuration.actor_storages.request_queues, 'RequestQueue'),
+        ):
             for storage_alias, storage_id in mapping.items():
-                if storage_alias == "default":
-                    # This is how the default storage is stored in the default kvs
-                    storage_alias="__default__"
-
-                configuration_mapping[AliasResolver(
-                    storage_type=convert_name(config_storage_type),
-                    alias=storage_alias,
-                    configuration=configuration,
-                )._storage_key] = storage_id
+                configuration_mapping[
+                    cls(  # noqa: SLF001# It is ok in own classmethod.
+                        storage_type=storage_type,
+                        alias='__default__' if storage_alias == 'default' else storage_alias,
+                        configuration=configuration,
+                    )._storage_key
+                ] = storage_id
 
         # Aliased storage can be also default storage!!!
         # Should we store such second alias to the default storage or ignore it in such case? Probably
 
         # What if existing default dataset already has conflicting keys?
         # Just override it, that will teach it to have conflicting values!
         client = await cls._get_default_kvs_client(configuration=configuration)
-        existing_mapping = (await client.get_record(cls._ALIAS_MAPPING_KEY) or {"value":{}}).get("value")
+        existing_mapping = ((await client.get_record(cls._ALIAS_MAPPING_KEY)) or {'value': {}}).get('value',
+                                                                                                    {})
         await client.set_record(cls._ALIAS_MAPPING_KEY, {**existing_mapping, **configuration_mapping})

tests/unit/actor/test_configuration.py

@@ -1,3 +1,4 @@
+import json
 from pathlib import Path
 
 import pytest
@@ -7,6 +8,7 @@
 from crawlee.configuration import Configuration as CrawleeConfiguration
 from crawlee.crawlers import BasicCrawler
 from crawlee.errors import ServiceConflictError
+from crawlee.storage_clients import MemoryStorageClient
 
 from apify import Actor
 from apify import Configuration as ApifyConfiguration