localstack-core 4.6.1.dev60__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/services/stepfunctions/quotas.py

@@ -1,12 +1,11 @@
-import json
-from typing import Final, Union
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
 
 MAX_STATE_SIZE_UTF8_BYTES: Final[int] = 256 * 1024  # 256 KB of data as a UTF-8 encoded string.
 
 
-def is_within_size_quota(value: Union[str, json]) -> bool:
+def is_within_size_quota(value: str | Any) -> bool:
     item_str = value if isinstance(value, str) else to_json_str(value)
     item_bytes = item_str.encode("utf-8")
     len_item_bytes = len(item_bytes)

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_activity.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -14,14 +14,14 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class StepFunctionsActivityProperties(TypedDict):
-    Name: Optional[str]
-    Arn: Optional[str]
-    Tags: Optional[list[TagsEntry]]
+    Name: str | None
+    Arn: str | None
+    Tags: list[TagsEntry] | None
 
 
 class TagsEntry(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_activity_plugin.py

@@ -1,5 +1,3 @@
-from typing import Optional, Type
-
 from localstack.services.cloudformation.resource_provider import (
     CloudFormationResourceProviderPlugin,
     ResourceProvider,
@@ -10,7 +8,7 @@ class StepFunctionsActivityProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::StepFunctions::Activity"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.stepfunctions.resource_providers.aws_stepfunctions_activity import (

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_statemachine.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import json
 import re
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -18,48 +18,48 @@ from localstack.utils.strings import to_str
 
 
 class StepFunctionsStateMachineProperties(TypedDict):
-    RoleArn: Optional[str]
-    Arn: Optional[str]
-    Definition: Optional[dict]
-    DefinitionS3Location: Optional[S3Location]
-    DefinitionString: Optional[str]
-    DefinitionSubstitutions: Optional[dict]
-    LoggingConfiguration: Optional[LoggingConfiguration]
-    Name: Optional[str]
-    StateMachineName: Optional[str]
-    StateMachineRevisionId: Optional[str]
-    StateMachineType: Optional[str]
-    Tags: Optional[list[TagsEntry]]
-    TracingConfiguration: Optional[TracingConfiguration]
+    RoleArn: str | None
+    Arn: str | None
+    Definition: dict | None
+    DefinitionS3Location: S3Location | None
+    DefinitionString: str | None
+    DefinitionSubstitutions: dict | None
+    LoggingConfiguration: LoggingConfiguration | None
+    Name: str | None
+    StateMachineName: str | None
+    StateMachineRevisionId: str | None
+    StateMachineType: str | None
+    Tags: list[TagsEntry] | None
+    TracingConfiguration: TracingConfiguration | None
 
 
 class CloudWatchLogsLogGroup(TypedDict):
-    LogGroupArn: Optional[str]
+    LogGroupArn: str | None
 
 
 class LogDestination(TypedDict):
-    CloudWatchLogsLogGroup: Optional[CloudWatchLogsLogGroup]
+    CloudWatchLogsLogGroup: CloudWatchLogsLogGroup | None
 
 
 class LoggingConfiguration(TypedDict):
-    Destinations: Optional[list[LogDestination]]
-    IncludeExecutionData: Optional[bool]
-    Level: Optional[str]
+    Destinations: list[LogDestination] | None
+    IncludeExecutionData: bool | None
+    Level: str | None
 
 
 class TracingConfiguration(TypedDict):
-    Enabled: Optional[bool]
+    Enabled: bool | None
 
 
 class S3Location(TypedDict):
-    Bucket: Optional[str]
-    Key: Optional[str]
-    Version: Optional[str]
+    Bucket: str | None
+    Key: str | None
+    Version: str | None
 
 
 class TagsEntry(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_statemachine_plugin.py

@@ -1,5 +1,3 @@
-from typing import Optional, Type
-
 from localstack.services.cloudformation.resource_provider import (
     CloudFormationResourceProviderPlugin,
     ResourceProvider,
@@ -10,7 +8,7 @@ class StepFunctionsStateMachineProviderPlugin(CloudFormationResourceProviderPlug
     name = "AWS::StepFunctions::StateMachine"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.stepfunctions.resource_providers.aws_stepfunctions_statemachine import (

localstack/services/stepfunctions/stepfunctions_utils.py

@@ -1,6 +1,5 @@
 import base64
 import logging
-from typing import Dict
 
 from localstack.aws.api.stepfunctions import ValidationException
 from localstack.aws.connect import connect_to
@@ -11,7 +10,7 @@ from localstack.utils.strings import to_bytes, to_str
 LOG = logging.getLogger(__name__)
 
 
-def await_sfn_execution_result(execution_arn: str, timeout_secs: int = 60) -> Dict:
+def await_sfn_execution_result(execution_arn: str, timeout_secs: int = 60) -> dict:
     """Wait until the given SFN execution ARN is no longer in RUNNING status, then return execution result."""
 
     arn_data = parse_arn(execution_arn)

localstack/services/stores.py

@@ -30,9 +30,9 @@ While not recommended, store classes may define member helper functions and prop
 """
 
 import re
-from collections.abc import Callable
+from collections.abc import Callable, Iterator
 from threading import RLock
-from typing import Any, Generic, Iterator, Type, TypeVar, Union
+from typing import Any, Generic, TypeVar
 
 from localstack import config
 from localstack.utils.aws.aws_stack import get_valid_regions_for_service
@@ -52,7 +52,7 @@ class LocalAttribute:
     Descriptor protocol for marking store attributes as local to a region.
     """
 
-    def __init__(self, default: Union[Callable, int, float, str, bool, None]):
+    def __init__(self, default: Callable | int | float | str | bool | None):
         """
         :param default: Default value assigned to the local attribute. Must be a scalar
             or a callable.
@@ -81,7 +81,7 @@ class CrossRegionAttribute:
     Descriptor protocol for marking store attributes as shared across all regions.
     """
 
-    def __init__(self, default: Union[Callable, int, float, str, bool, None]):
+    def __init__(self, default: Callable | int | float | str | bool | None):
         """
         :param default: The default value assigned to the cross-region attribute.
             This must be a scalar or a callable.
@@ -122,7 +122,7 @@ class CrossAccountAttribute:
     This should be used for resources that are identified by ARNs.
     """
 
-    def __init__(self, default: Union[Callable, int, float, str, bool, None]):
+    def __init__(self, default: Callable | int | float | str | bool | None):
         """
         :param default: The default value assigned to the cross-account attribute.
             This must be a scalar or a callable.
@@ -198,7 +198,7 @@ class RegionBundle(dict, Generic[BaseStoreType]):
     def __init__(
         self,
         service_name: str,
-        store: Type[BaseStoreType],
+        store: type[BaseStoreType],
         account_id: str,
         validate: bool = True,
         lock: RLock = None,
@@ -238,7 +238,7 @@ class RegionBundle(dict, Generic[BaseStoreType]):
 
                 store_obj._global = self._global
                 store_obj._universal = self._universal
-                store_obj.service_name = self.service_name
+                store_obj._service_name = self.service_name
                 store_obj._account_id = self.account_id
                 store_obj._region_name = region_name
 
@@ -286,7 +286,7 @@ class AccountRegionBundle(dict, Generic[BaseStoreType]):
     Encapsulation for all stores for all AWS account IDs.
     """
 
-    def __init__(self, service_name: str, store: Type[BaseStoreType], validate: bool = True):
+    def __init__(self, service_name: str, store: type[BaseStoreType], validate: bool = True):
         """
         :param service_name: Name of the service. Must be a valid service defined in botocore.
         :param store: Class definition of the Store

localstack/services/transcribe/packages.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from localstack.packages import Package
 from localstack.packages.core import PythonPackageInstaller
 
@@ -13,7 +11,7 @@ class VoskPackage(Package[PythonPackageInstaller]):
     def _get_installer(self, version: str) -> PythonPackageInstaller:
         return VoskPackageInstaller(version)
 
-    def get_versions(self) -> List[str]:
+    def get_versions(self) -> list[str]:
         return [_VOSK_DEFAULT_VERSION]
 
 

localstack/services/transcribe/provider.py

@@ -5,7 +5,7 @@ import threading
 import wave
 from functools import cache
 from pathlib import Path
-from typing import Any, Tuple
+from typing import Any
 from zipfile import ZipFile
 
 from localstack import config
@@ -277,7 +277,7 @@ class TranscribeProvider(TranscribeApi):
     # Threads
     #
 
-    def _run_transcription_job(self, args: Tuple[TranscribeStore, str]) -> None:
+    def _run_transcription_job(self, args: tuple[TranscribeStore, str]) -> None:
         store, job_name = args
 
         job = store.transcription_jobs[job_name]
@@ -412,4 +412,9 @@ class TranscribeProvider(TranscribeApi):
             job["FailureReason"] = failure_reason or str(exc)
             job["TranscriptionJobStatus"] = TranscriptionJobStatus.FAILED
 
-            LOG.exception("Transcription job %s failed: %s", job_name, job["FailureReason"])
+            LOG.error(
+                "Transcription job %s failed: %s",
+                job_name,
+                job["FailureReason"],
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )

localstack/state/codecs.py

@@ -0,0 +1,61 @@
+"""Factory for encoders and decoders"""
+
+from localstack import config
+from localstack.state import Decoder, Encoder
+from localstack.state.pickle import PickleDecoder, PickleEncoder
+
+ENCODERS = {
+    "dill": PickleEncoder,
+}
+"""Encoders that map to the name of ``STATE_SERIALIZATION_BACKEND``."""
+
+DECODERS = {
+    "dill": PickleDecoder,
+}
+"""Decoders that map to the name of ``STATE_SERIALIZATION_BACKEND``."""
+
+
+def create_encoder(encoder_type: str) -> Encoder:
+    cls = ENCODERS.get(encoder_type)
+    if cls is None:
+        raise ValueError(f"Unknown encoder type: {encoder_type}")
+    return cls()
+
+
+def create_decoder(decoder_type: str) -> Decoder:
+    cls = DECODERS.get(decoder_type, PickleDecoder)
+    if cls is None:
+        raise ValueError(f"Unknown decoder type: {decoder_type}")
+    return cls()
+
+
+def get_default_encoder() -> Encoder:
+    """
+    Gets the default encoder based on the state serialization backend defined in the configuration
+    ``STATE_SERIALIZATION_BACKEND``.
+
+    If the serialization backend specified in the configuration leads to an error
+    (such as an invalid backend), a ``PickleEncoder`` is returned as a fallback.
+
+    :return: The default encoder for state serialization.
+    """
+    try:
+        return create_encoder(config.STATE_SERIALIZATION_BACKEND)
+    except ValueError:
+        return PickleEncoder()
+
+
+def get_default_decoder() -> Decoder:
+    """
+    Gets the default decoder based on the state serialization backend defined in the configuration
+    ``STATE_SERIALIZATION_BACKEND``.
+
+    If the serialization backend specified in the configuration leads to an error
+    (such as an invalid backend), a ``PickleDecoder`` is returned as a fallback.
+
+    :return: The default decoder for state serialization.
+    """
+    try:
+        return create_decoder(config.STATE_SERIALIZATION_BACKEND)
+    except ValueError:
+        return PickleDecoder()

localstack/state/core.py

@@ -97,42 +97,48 @@ class AssetDirectory:
 
 
 class Encoder:
-    def encodes(self, obj: Any) -> bytes:
+    def encodes(self, obj: Any, py_type: type = None) -> bytes:
         """
         Encode an object into bytes.
 
         :param obj: the object to encode
+        :param py_type: the type of the object. needed by some encoders that don't have implicit type knowledge.
         :return: the encoded object
         """
         b = io.BytesIO()
         self.encode(obj, b)
         return b.getvalue()
 
-    def encode(self, obj: Any, file: IO[bytes]):
+    def encode(self, obj: Any, file: IO[bytes], py_type: type = None):
         """
         Encode an object into bytes.
 
         :param obj: the object to encode
+        :param py_type: the type of the object. needed by some encoders that don't have implicit type knowledge.
         :param file: the file to write the encoded data into
         """
         raise NotImplementedError
 
 
 class Decoder:
-    def decodes(self, data: bytes) -> Any:
+    def decodes(self, data: bytes, py_type: type = None) -> Any:
         """
         Decode a previously encoded object.
 
         :param data: the encoded object to decode
+        :param py_type: the type that is expected as return type. Needed by some decoders that don't have implicit
+        type knowledge.
         :return: the decoded object
         """
-        return self.decode(io.BytesIO(data))
+        return self.decode(io.BytesIO(data), py_type)
 
-    def decode(self, file: IO[bytes]) -> Any:
+    def decode(self, file: IO[bytes], py_type: type = None) -> Any:
         """
         Decode a previously encoded object.
 
         :param file: the io object containing the object to decode
+        :param py_type: the type that is expected as return type. Needed by some decoders that don't have implicit
+        type knowledge.
         :return: the decoded object
         """
         raise NotImplementedError

localstack/state/inspect.py

@@ -3,7 +3,7 @@
 import importlib
 import logging
 from functools import singledispatchmethod
-from typing import Any, Dict, Optional, TypedDict
+from typing import Any, TypedDict
 
 from moto.core.base_backend import BackendDict
 
@@ -17,14 +17,14 @@ class ServiceBackend(TypedDict, total=False):
     """Wrapper of the possible type of backends that a service can use."""
 
     localstack: AccountRegionBundle | None
-    moto: BackendDict | Dict | None
+    moto: BackendDict | dict | None
 
 
 class ServiceBackendCollectorVisitor(StateVisitor):
     """Implementation of StateVisitor meant to collect the backends that a given service use to hold its state."""
 
     store: AccountRegionBundle | None
-    backend_dict: BackendDict | Dict | None
+    backend_dict: BackendDict | dict | None
 
     def __init__(self) -> None:
         self.store = None
@@ -60,7 +60,7 @@ class ReflectionStateLocator:
 
     provider: Any
 
-    def __init__(self, provider: Optional[Any] = None, service: Optional[str] = None):
+    def __init__(self, provider: Any | None = None, service: str | None = None):
         self.provider = provider
         self.service = service or provider.service
 

localstack/state/pickle.py

@@ -29,7 +29,8 @@ https://dill.readthedocs.io/en/latest/index.html?highlight=register#dill.Pickler
 """
 
 import inspect
-from typing import Any, BinaryIO, Callable, Generic, Type, TypeVar
+from collections.abc import Callable
+from typing import Any, BinaryIO, Generic, TypeVar
 
 import dill
 from dill._dill import MetaCatchingDict
@@ -42,7 +43,7 @@ PythonPickler = Any
 """Type placeholder for pickle._Pickler (which has for instance the save_reduce method)"""
 
 
-def register(cls: Type = None, subclasses: bool = False):
+def register(cls: type = None, subclasses: bool = False):
     """
     Decorator to register a custom type or type tree into the dill pickling dispatcher table.
 
@@ -60,14 +61,14 @@ def register(cls: Type = None, subclasses: bool = False):
         elif callable(fn):
             add_dispatch_entry(cls, fn, subclasses=subclasses)
         else:
-            raise ValueError("cannot register %s" % fn)
+            raise ValueError(f"cannot register {fn}")
 
         return fn
 
     return _wrapper
 
 
-def reducer(cls: Type, restore: Callable = None, subclasses: bool = False):
+def reducer(cls: type, restore: Callable = None, subclasses: bool = False):
     """
     Convenience decorator to simplify the following pattern::
 
@@ -115,14 +116,14 @@ def reducer(cls: Type, restore: Callable = None, subclasses: bool = False):
 
 
 def add_dispatch_entry(
-    cls: Type, fn: Callable[[PythonPickler, Any], None], subclasses: bool = False
+    cls: type, fn: Callable[[PythonPickler, Any], None], subclasses: bool = False
 ):
     Pickler.dispatch_overwrite[cls] = fn
     if subclasses:
         Pickler.match_subclasses_of.add(cls)
 
 
-def remove_dispatch_entry(cls: Type):
+def remove_dispatch_entry(cls: type):
     try:
         del Pickler.dispatch_overwrite[cls]
     except KeyError:
@@ -136,42 +137,42 @@ def remove_dispatch_entry(cls: Type):
 
 def dumps(obj: Any) -> bytes:
     """
-    Pickle an object into bytes using a ``PickleEncoder``.
+    Pickle an object into bytes using a ``Encoder``.
 
     :param obj: the object to pickle
     :return: the pickled object
     """
-    return PickleEncoder().encodes(obj)
+    return get_default_encoder().encodes(obj)
 
 
 def dump(obj: Any, file: BinaryIO):
     """
-    Pickle an object into a buffer using a ``PickleEncoder``.
+    Pickle an object into a buffer using a ``Encoder``.
 
     :param obj: the object to pickle
     :param file: the IO buffer
     """
-    return PickleEncoder().encode(obj, file)
+    return get_default_encoder().encode(obj, file)
 
 
 def loads(data: bytes) -> Any:
     """
-    Unpickle am object from bytes using a ``PickleDecoder``.
+    Unpickle am object from bytes using a ``Decoder``.
 
     :param data: the pickled object
     :return: the unpickled object
     """
-    return PickleDecoder().decodes(data)
+    return get_default_decoder().decodes(data)
 
 
 def load(file: BinaryIO) -> Any:
     """
-    Unpickle am object from a buffer using a ``PickleDecoder``.
+    Unpickle am object from a buffer using a ``Decoder``.
 
     :param file: the buffer containing the pickled object
     :return: the unpickled object
     """
-    return PickleDecoder().decode(file)
+    return get_default_decoder().decode(file)
 
 
 class _SuperclassMatchingTypeDict(MetaCatchingDict):
@@ -187,7 +188,7 @@ class _SuperclassMatchingTypeDict(MetaCatchingDict):
 
     """
 
-    def __init__(self, seq=None, match_subclasses_of: set[Type] = None):
+    def __init__(self, seq=None, match_subclasses_of: set[type] = None):
         if seq is not None:
             super().__init__(seq)
         else:
@@ -212,8 +213,8 @@ class Pickler(dill.Pickler):
     Custom dill pickler that considers dispatchers and subclass dispatchers registered via ``register``.
     """
 
-    match_subclasses_of: set[Type] = set()
-    dispatch_overwrite: dict[Type, Callable] = {}
+    match_subclasses_of: set[type] = set()
+    dispatch_overwrite: dict[type, Callable] = {}
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
@@ -231,12 +232,12 @@ class PickleEncoder(Encoder):
     extended with custom serializers.
     """
 
-    pickler_class: Type[dill.Pickler]
+    pickler_class: type[dill.Pickler]
 
-    def __init__(self, pickler_class: Type[dill.Pickler] = None):
+    def __init__(self, pickler_class: type[dill.Pickler] = None):
         self.pickler_class = pickler_class or Pickler
 
-    def encode(self, obj: Any, file: BinaryIO):
+    def encode(self, obj: Any, file: BinaryIO, py_type: type = None) -> Any:
         return self.pickler_class(file).dump(obj)
 
 
@@ -246,15 +247,27 @@ class PickleDecoder(Decoder):
     extended with custom serializers.
     """
 
-    unpickler_class: Type[dill.Unpickler]
+    unpickler_class: type[dill.Unpickler]
 
-    def __init__(self, unpickler_class: Type[dill.Unpickler] = None):
+    def __init__(self, unpickler_class: type[dill.Unpickler] = None):
         self.unpickler_class = unpickler_class or dill.Unpickler
 
-    def decode(self, file: BinaryIO) -> Any:
+    def decode(self, file: BinaryIO, py_type=None) -> Any:
         return self.unpickler_class(file).load()
 
 
+def get_default_encoder() -> Encoder:
+    from .codecs import get_default_encoder
+
+    return get_default_encoder()
+
+
+def get_default_decoder() -> Decoder:
+    from .codecs import get_default_decoder
+
+    return get_default_decoder()
+
+
 class ObjectStateReducer(Generic[_T]):
     """
     A generalization of the following pattern::

localstack/testing/aws/asf_utils.py

@@ -3,12 +3,13 @@ import importlib.util
 import inspect
 import pkgutil
 import re
+from re import Pattern
 from types import FunctionType, ModuleType, NoneType, UnionType
-from typing import Optional, Pattern, Union, get_args, get_origin
+from typing import Union, get_args, get_origin
 
 
 def _import_submodules(
-    package_name: str, module_regex: Optional[Pattern] = None, recursive: bool = True
+    package_name: str, module_regex: Pattern | None = None, recursive: bool = True
 ) -> dict[str, ModuleType]:
     """
     Imports all submodules of the given package with the defined (optional) module_suffix.

localstack/testing/aws/cloudformation_utils.py

@@ -29,7 +29,7 @@ def load_template_file(file_path: str | os.PathLike, *, path_ctx: str | os.PathL
     elif not file_path_obj.is_absolute():
         raise ValueError("Provided path must be absolute if no path_ctx is provided")
 
-    return load_file(file_path_obj.absolute())
+    return load_file(file_path_obj.absolute(), strict=True)
 
 
 # TODO: TBH this utility really doesn't add anything, probably better to just remove it