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

localstack/services/cloudformation/engine/v2/change_set_model_validator.py

@@ -0,0 +1,183 @@
+import re
+from typing import Any
+
+from botocore.exceptions import ParamValidationError
+
+from localstack.services.cloudformation.engine.v2.change_set_model import (
+    NodeIntrinsicFunction,
+    NodeProperty,
+    NodeResource,
+    NodeTemplate,
+    Nothing,
+    is_nothing,
+)
+from localstack.services.cloudformation.engine.v2.change_set_model_preproc import (
+    _PSEUDO_PARAMETERS,
+    ChangeSetModelPreproc,
+    PreprocEntityDelta,
+    PreprocResource,
+)
+
+
+class ChangeSetModelValidator(ChangeSetModelPreproc):
+    def validate(self):
+        self.process()
+
+    def visit_node_template(self, node_template: NodeTemplate):
+        self.visit(node_template.mappings)
+        self.visit(node_template.resources)
+        self.visit(node_template.parameters)
+
+    def visit_node_intrinsic_function_fn_get_att(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ) -> PreprocEntityDelta:
+        try:
+            return super().visit_node_intrinsic_function_fn_get_att(node_intrinsic_function)
+        except RuntimeError:
+            return self.visit(node_intrinsic_function.arguments)
+
+    def visit_node_intrinsic_function_fn_sub(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ) -> PreprocEntityDelta:
+        def _compute_sub(args: str | list[Any], select_before: bool) -> str:
+            # TODO: add further schema validation.
+            string_template: str
+            sub_parameters: dict
+            if isinstance(args, str):
+                string_template = args
+                sub_parameters = {}
+            elif (
+                isinstance(args, list)
+                and len(args) == 2
+                and isinstance(args[0], str)
+                and isinstance(args[1], dict)
+            ):
+                string_template = args[0]
+                sub_parameters = args[1]
+            else:
+                raise RuntimeError(
+                    "Invalid arguments shape for Fn::Sub, expected a String "
+                    f"or a Tuple of String and Map but got '{args}'"
+                )
+            sub_string = string_template
+            template_variable_names = re.findall("\\${([^}]+)}", string_template)
+            for template_variable_name in template_variable_names:
+                template_variable_value = Nothing
+
+                # Try to resolve the variable name as pseudo parameter.
+                if template_variable_name in _PSEUDO_PARAMETERS:
+                    template_variable_value = self._resolve_pseudo_parameter(
+                        pseudo_parameter_name=template_variable_name
+                    )
+
+                # Try to resolve the variable name as an entry to the defined parameters.
+                elif template_variable_name in sub_parameters:
+                    template_variable_value = sub_parameters[template_variable_name]
+
+                # Try to resolve the variable name as GetAtt.
+                elif "." in template_variable_name:
+                    try:
+                        template_variable_value = self._resolve_attribute(
+                            arguments=template_variable_name, select_before=select_before
+                        )
+                    except RuntimeError:
+                        pass
+
+                # Try to resolve the variable name as Ref.
+                else:
+                    try:
+                        resource_delta = self._resolve_reference(logical_id=template_variable_name)
+                        template_variable_value = (
+                            resource_delta.before if select_before else resource_delta.after
+                        )
+                        if isinstance(template_variable_value, PreprocResource):
+                            template_variable_value = template_variable_value.physical_resource_id
+                    except RuntimeError:
+                        pass
+
+                if is_nothing(template_variable_value):
+                    # override the base method just for this line to prevent accessing the
+                    # resource properties since we are not deploying any resources
+                    template_variable_value = ""
+
+                if not isinstance(template_variable_value, str):
+                    template_variable_value = str(template_variable_value)
+
+                sub_string = sub_string.replace(
+                    f"${{{template_variable_name}}}", template_variable_value
+                )
+
+            # FIXME: the following type reduction is ported from v1; however it appears as though such
+            #        reduction is not performed by the engine, and certainly not at this depth given the
+            #        lack of context. This section should be removed with Fn::Sub always retuning a string
+            #        and the resource providers reviewed.
+            account_id = self._change_set.account_id
+            is_another_account_id = sub_string.isdigit() and len(sub_string) == len(account_id)
+            if sub_string == account_id or is_another_account_id:
+                result = sub_string
+            elif sub_string.isdigit():
+                result = int(sub_string)
+            else:
+                try:
+                    result = float(sub_string)
+                except ValueError:
+                    result = sub_string
+            return result
+
+        arguments_delta = self.visit(node_intrinsic_function.arguments)
+        arguments_before = arguments_delta.before
+        arguments_after = arguments_delta.after
+        before = self._before_cache.get(node_intrinsic_function.scope, Nothing)
+        if is_nothing(before) and not is_nothing(arguments_before):
+            before = _compute_sub(args=arguments_before, select_before=True)
+        after = self._after_cache.get(node_intrinsic_function.scope, Nothing)
+        if is_nothing(after) and not is_nothing(arguments_after):
+            after = _compute_sub(args=arguments_after, select_before=False)
+        return PreprocEntityDelta(before=before, after=after)
+
+    def visit_node_intrinsic_function_fn_transform(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ):
+        # TODO Research this issue:
+        # Function is already resolved in the template reaching this point
+        # But transformation is still present in update model
+        return self.visit(node_intrinsic_function.arguments)
+
+    def visit_node_intrinsic_function_fn_split(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ) -> PreprocEntityDelta:
+        try:
+            # If an argument is a Parameter it should be resolved, any other case, ignore it
+            return super().visit_node_intrinsic_function_fn_split(node_intrinsic_function)
+        except RuntimeError:
+            return self.visit(node_intrinsic_function.arguments)
+
+    def visit_node_intrinsic_function_fn_select(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ) -> PreprocEntityDelta:
+        try:
+            # If an argument is a Parameter it should be resolved, any other case, ignore it
+            return super().visit_node_intrinsic_function_fn_select(node_intrinsic_function)
+        except RuntimeError:
+            return self.visit(node_intrinsic_function.arguments)
+
+    def visit_node_resource(self, node_resource: NodeResource) -> PreprocEntityDelta:
+        try:
+            if delta := super().visit_node_resource(node_resource):
+                return delta
+            return super().visit_node_properties(node_resource.properties)
+        except RuntimeError:
+            return super().visit_node_properties(node_resource.properties)
+
+    def visit_node_property(self, node_property: NodeProperty) -> PreprocEntityDelta:
+        try:
+            return super().visit_node_property(node_property)
+        except ParamValidationError:
+            return self.visit(node_property.value)
+
+    # ignore errors from dynamic replacements
+    def _maybe_perform_dynamic_replacements(self, delta: PreprocEntityDelta) -> PreprocEntityDelta:
+        try:
+            return super()._maybe_perform_dynamic_replacements(delta)
+        except Exception:
+            return delta

localstack/services/cloudformation/engine/v2/change_set_model_visitor.py

@@ -54,6 +54,7 @@ class ChangeSetModelVisitor(abc.ABC):
         # entities (parameters, mappings, conditions, etc.). Then compute the output fields; computing
         # only the output fields would only result in the deployment logic of the referenced outputs
         # being evaluated, hence enforce the visiting of all the resources first.
+        self.visit(node_template.conditions)
         self.visit(node_template.resources)
         self.visit(node_template.outputs)
 
@@ -177,6 +178,11 @@ class ChangeSetModelVisitor(abc.ABC):
     ):
         self.visit_children(node_intrinsic_function)
 
+    def visit_node_intrinsic_function_fn_import_value(
+        self, node_intrinsic_function: NodeIntrinsicFunction
+    ):
+        self.visit_children(node_intrinsic_function)
+
     def visit_node_divergence(self, node_divergence: NodeDivergence):
         self.visit_children(node_divergence)
 

localstack/services/cloudformation/engine/v2/resolving.py

@@ -0,0 +1,102 @@
+import json
+import logging
+import re
+from dataclasses import dataclass
+from typing import Any
+
+from botocore.exceptions import ClientError
+
+from localstack.aws.connect import connect_to
+
+LOG = logging.getLogger(__name__)
+
+# CloudFormation allows using dynamic references in `Fn::Sub` expressions, so we must make sure
+# we don't capture the parameter usage by excluding ${} characters
+REGEX_DYNAMIC_REF = re.compile(r"{{resolve:([^:]+):([^${}]+)}}")
+
+
+@dataclass
+class DynamicReference:
+    service_name: str
+    reference_key: str
+
+
+def extract_dynamic_reference(value: Any) -> DynamicReference | None:
+    if isinstance(value, str):
+        if dynamic_ref_match := REGEX_DYNAMIC_REF.search(value):
+            return DynamicReference(dynamic_ref_match[1], dynamic_ref_match[2])
+    return None
+
+
+def perform_dynamic_reference_lookup(
+    reference: DynamicReference, account_id: str, region_name: str
+) -> str | None:
+    # basic dynamic reference support
+    # see: https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/dynamic-references.html
+    # technically there are more restrictions for each of these services but checking each of these
+    # isn't really necessary for the current level of emulation
+
+    # only these 3 services are supported for dynamic references right now
+    if reference.service_name == "ssm":
+        ssm_client = connect_to(aws_access_key_id=account_id, region_name=region_name).ssm
+        try:
+            return ssm_client.get_parameter(Name=reference.reference_key)["Parameter"]["Value"]
+        except ClientError as e:
+            LOG.error("client error accessing SSM parameter '%s': %s", reference.reference_key, e)
+            raise
+    elif reference.service_name == "ssm-secure":
+        ssm_client = connect_to(aws_access_key_id=account_id, region_name=region_name).ssm
+        try:
+            return ssm_client.get_parameter(Name=reference.reference_key, WithDecryption=True)[
+                "Parameter"
+            ]["Value"]
+        except ClientError as e:
+            LOG.error("client error accessing SSM parameter '%s': %s", reference.reference_key, e)
+            raise
+    elif reference.service_name == "secretsmanager":
+        # reference key needs to be parsed further
+        # because {{resolve:secretsmanager:secret-id:secret-string:json-key:version-stage:version-id}}
+        # we match for "secret-id:secret-string:json-key:version-stage:version-id"
+        # where
+        #   secret-id can either be the secret name or the full ARN of the secret
+        #   secret-string *must* be SecretString
+        #   all other values are optional
+        secret_id = reference.reference_key
+        [json_key, version_stage, version_id] = [None, None, None]
+        if "SecretString" in reference.reference_key:
+            parts = reference.reference_key.split(":SecretString:")
+            secret_id = parts[0]
+            # json-key, version-stage and version-id are optional.
+            [json_key, version_stage, version_id] = f"{parts[1]}::".split(":")[:3]
+
+        kwargs = {}  # optional args for get_secret_value
+        if version_id:
+            kwargs["VersionId"] = version_id
+        if version_stage:
+            kwargs["VersionStage"] = version_stage
+
+        secretsmanager_client = connect_to(
+            aws_access_key_id=account_id, region_name=region_name
+        ).secretsmanager
+        try:
+            secret_value = secretsmanager_client.get_secret_value(SecretId=secret_id, **kwargs)[
+                "SecretString"
+            ]
+        except ClientError:
+            LOG.error("client error while trying to access key '%s': %s", secret_id)
+            raise
+
+        if json_key:
+            json_secret = json.loads(secret_value)
+            if json_key not in json_secret:
+                raise RuntimeError(
+                    f"JSON value for {reference.service_name}.{reference.reference_key} not present"
+                )
+            return str(json_secret[json_key])
+        else:
+            return str(secret_value)
+
+    LOG.warning(
+        "Unsupported service for dynamic parameter: service_name=%s", reference.service_name
+    )
+    return None

localstack/services/cloudformation/engine/yaml_parser.py

@@ -1,5 +1,7 @@
 import yaml
 
+from localstack.services.cloudformation.engine.validations import ValidationError
+
 
 def construct_raw(_, node):
     return node.value
@@ -60,5 +62,10 @@ customloader = NoDatesSafeLoader
 yaml.add_multi_constructor("!", shorthand_constructor, customloader)
 
 
-def parse_yaml(input_data: str):
-    return yaml.load(input_data, customloader)
+def parse_yaml(input_data: str) -> dict:
+    parsed = yaml.load(input_data, Loader=customloader)
+
+    if not isinstance(parsed, dict):
+        raise ValidationError("Template format error: unsupported structure.")
+
+    return parsed

localstack/services/cloudformation/provider.py

@@ -137,6 +137,9 @@ ARN_CHANGESET_REGEX = re.compile(
 ARN_STACK_REGEX = re.compile(
     r"arn:(aws|aws-us-gov|aws-cn):cloudformation:[-a-zA-Z0-9]+:\d{12}:stack/[a-zA-Z][-a-zA-Z0-9]*/[-a-zA-Z0-9:/._+]+"
 )
+ARN_STACK_SET_REGEX = re.compile(
+    r"arn:(aws|aws-us-gov|aws-cn):cloudformation:[-a-zA-Z0-9]+:\d{12}:stack-set/[a-zA-Z][-a-zA-Z0-9]*/[-a-zA-Z0-9:/._+]+"
+)
 
 
 def clone_stack_params(stack_params):
@@ -156,7 +159,7 @@ def find_stack_instance(stack_set: StackSet, account: str, region: str):
 
 def stack_not_found_error(stack_name: str):
     # FIXME
-    raise ValidationError("Stack with id %s does not exist" % stack_name)
+    raise ValidationError(f"Stack with id {stack_name} does not exist")
 
 
 def not_found_error(message: str):
@@ -302,8 +305,8 @@ class CloudformationProvider(CloudformationApi):
             deployer.deploy_stack()
         except Exception as e:
             stack.set_stack_status("CREATE_FAILED")
-            msg = 'Unable to create stack "%s": %s' % (stack.stack_name, e)
-            LOG.exception("%s")
+            msg = f'Unable to create stack "{stack.stack_name}": {e}'
+            LOG.error("%s", exc_info=LOG.isEnabledFor(logging.DEBUG))
             raise ValidationError(msg) from e
 
         return CreateStackOutput(StackId=stack.stack_id)
@@ -420,7 +423,7 @@ class CloudformationProvider(CloudformationApi):
         except Exception as e:
             stack.set_stack_status("UPDATE_FAILED")
             msg = f'Unable to update stack "{stack_name}": {e}'
-            LOG.exception("%s", msg)
+            LOG.error("%s", msg, exc_info=LOG.isEnabledFor(logging.DEBUG))
             raise ValidationError(msg) from e
 
         return UpdateStackOutput(StackId=stack.stack_id)
@@ -602,6 +605,8 @@ class CloudformationProvider(CloudformationApi):
         req_params = request
         change_set_type = req_params.get("ChangeSetType", "UPDATE")
         stack_name = req_params.get("StackName")
+        if not stack_name:
+            raise ValidationError("Member must have length greater than or equal to 1")
         change_set_name = req_params.get("ChangeSetName")
         template_body = req_params.get("TemplateBody")
         # s3 or secretsmanager url
@@ -924,7 +929,7 @@ class CloudformationProvider(CloudformationApi):
         self, context: RequestContext, next_token: NextToken = None, **kwargs
     ) -> ListExportsOutput:
         state = get_cloudformation_store(context.account_id, context.region)
-        return ListExportsOutput(Exports=state.exports)
+        return ListExportsOutput(Exports=state.exports.values())
 
     @handler("ListImports")
     def list_imports(
@@ -1049,7 +1054,7 @@ class CloudformationProvider(CloudformationApi):
                 Description=valid_template.get("Description"), Parameters=parameters
             )
         except Exception as e:
-            LOG.exception("Error validating template")
+            LOG.error("Error validating template", exc_info=LOG.isEnabledFor(logging.DEBUG))
             raise ValidationError("Template Validation Error") from e
 
     # =======================================

localstack/services/cloudformation/provider_utils.py

@@ -9,9 +9,9 @@ import builtins
 import json
 import re
 import uuid
+from collections.abc import Callable
 from copy import deepcopy
 from pathlib import Path
-from typing import Callable, List, Optional
 
 from botocore.model import Shape, StructureShape
 
@@ -73,9 +73,12 @@ def recurse_properties(properties: dict, fn: Callable) -> dict:
     return _recurse_properties(deepcopy(properties), fn)
 
 
-def keys_pascalcase_to_lower_camelcase(model: dict) -> dict:
+def keys_pascalcase_to_lower_camelcase(model: dict, skip_keys: set = None) -> dict:
     """Recursively change any dicts keys to lower camelcase"""
 
+    if skip_keys:
+        return _pascal_to_camel_keys_preserve_values(model, skip_keys)
+
     def _keys_pascalcase_to_lower_camelcase(obj):
         if isinstance(obj, dict):
             return {convert_pascalcase_to_lower_camelcase(k): v for k, v in obj.items()}
@@ -85,6 +88,33 @@ def keys_pascalcase_to_lower_camelcase(model: dict) -> dict:
     return _recurse_properties(model, _keys_pascalcase_to_lower_camelcase)
 
 
+def _pascal_to_camel_keys_preserve_values(model: dict, skip_keys: set = None) -> dict:
+    """
+    Variant of keys_pascalcase_to_lower_camelcase
+    All VALUES of provided keys are skipped and not transformed to lower camelcase.
+    The keys themselves will be transformed.
+    The function simply stops recursion if a key matches, so make sure no lower level values are ignored.
+    """
+    skip_keys = skip_keys or set()
+
+    def _transform(obj):
+        if isinstance(obj, dict):
+            new_dict = {}
+            for k, v in obj.items():
+                new_key = convert_pascalcase_to_lower_camelcase(k)
+                if k in skip_keys:
+                    new_dict[new_key] = v
+                else:
+                    new_dict[new_key] = _transform(v)
+            return new_dict
+        elif isinstance(obj, list):
+            return [_transform(i) for i in obj]
+        else:
+            return obj
+
+    return _transform(model)
+
+
 def keys_lower_camelcase_to_pascalcase(model: dict) -> dict:
     """Recursively change any dicts keys to PascalCase"""
 
@@ -152,7 +182,7 @@ def fix_boto_parameters_based_on_report(original_params: dict, report: str) -> d
         cast_class = getattr(builtins, valid_class)
         old_value = get_nested(params, param_name)
 
-        if cast_class == bool and str(old_value).lower() in ["true", "false"]:
+        if isinstance(cast_class, bool) and str(old_value).lower() in ["true", "false"]:
             new_value = str(old_value).lower() == "true"
         else:
             new_value = cast_class(old_value)
@@ -213,7 +243,7 @@ def convert_request_kwargs(parameters: dict, input_shape: StructureShape) -> dic
     return transformed_dict
 
 
-def convert_values_to_numbers(input_dict: dict, keys_to_skip: Optional[List[str]] = None):
+def convert_values_to_numbers(input_dict: dict, keys_to_skip: list[str] | None = None):
     """
     Recursively converts all string values that represent valid integers
     in a dictionary (including nested dictionaries and lists) to integers.

localstack/services/cloudformation/resource_provider.py

@@ -5,11 +5,12 @@ import logging
 import re
 import time
 import uuid
+from collections.abc import Callable
 from dataclasses import dataclass, field
 from enum import Enum, auto
 from logging import Logger
 from math import ceil
-from typing import TYPE_CHECKING, Any, Callable, Generic, Optional, Type, TypedDict, TypeVar
+from typing import TYPE_CHECKING, Any, Generic, TypedDict, TypeVar
 
 import botocore
 from botocore.client import BaseClient
@@ -51,7 +52,7 @@ LOG = logging.getLogger(__name__)
 
 Properties = TypeVar("Properties")
 
-PUBLIC_REGISTRY: dict[str, Type[ResourceProvider]] = {}
+PUBLIC_REGISTRY: dict[str, type[ResourceProvider]] = {}
 
 PROVIDER_DEFAULTS = {}  # TODO: remove this after removing patching in -ext
 
@@ -66,12 +67,12 @@ class OperationStatus(Enum):
 @dataclass
 class ProgressEvent(Generic[Properties]):
     status: OperationStatus
-    resource_model: Optional[Properties] = None
-    resource_models: Optional[list[Properties]] = None
+    resource_model: Properties | None = None
+    resource_models: list[Properties] | None = None
 
     message: str = ""
-    result: Optional[str] = None
-    error_code: Optional[str] = None  # TODO: enum
+    result: str | None = None
+    error_code: str | None = None  # TODO: enum
     custom_context: dict = field(default_factory=dict)
 
 
@@ -84,7 +85,7 @@ class Credentials(TypedDict):
 class ResourceProviderPayloadRequestData(TypedDict):
     logicalResourceId: str
     resourceProperties: Properties
-    previousResourceProperties: Optional[Properties]
+    previousResourceProperties: Properties | None
     callerCredentials: Credentials
     providerCredentials: Credentials
     systemTags: dict[str, str]
@@ -184,8 +185,8 @@ class ResourceRequest(Generic[Properties]):
 
     custom_context: dict = field(default_factory=dict)
 
-    previous_state: Optional[Properties] = None
-    previous_tags: Optional[dict[str, str]] = None
+    previous_state: Properties | None = None
+    previous_tags: dict[str, str] | None = None
     tags: dict[str, str] = field(default_factory=dict)
 
 
@@ -235,7 +236,7 @@ def get_resource_type(resource: dict) -> str:
         LOG.warning(
             "Failed to retrieve resource type %s",
             resource.get("Type"),
-            exc_info=LOG.isEnabledFor(logging.DEBUG),
+            exc_info=LOG.isEnabledFor(logging.DEBUG) and config.CFN_VERBOSE_ERRORS,
         )
 
 
@@ -465,15 +466,18 @@ class ResourceProviderExecutor:
                             "A ResourceProvider should always have a SCHEMA property defined."
                         )
                     resource_type_schema = resource_provider.SCHEMA
-                    physical_resource_id = self.extract_physical_resource_id_from_model_with_schema(
-                        event.resource_model,
-                        raw_payload["resourceType"],
-                        resource_type_schema,
-                    )
+                    if raw_payload["action"] != "Remove":
+                        physical_resource_id = (
+                            self.extract_physical_resource_id_from_model_with_schema(
+                                event.resource_model,
+                                raw_payload["resourceType"],
+                                resource_type_schema,
+                            )
+                        )
 
-                    resource["PhysicalResourceId"] = physical_resource_id
-                    resource["Properties"] = event.resource_model
-                    resource["_last_deployed_state"] = copy.deepcopy(event.resource_model)
+                        resource["PhysicalResourceId"] = physical_resource_id
+                        resource["Properties"] = event.resource_model
+                        resource["_last_deployed_state"] = copy.deepcopy(event.resource_model)
                     return event
                 case OperationStatus.IN_PROGRESS:
                     # update the shared state
@@ -514,10 +518,14 @@ class ResourceProviderExecutor:
                 try:
                     return resource_provider.update(request)
                 except NotImplementedError:
+                    feature_request_url = "https://github.com/localstack/localstack/issues/new?template=feature-request.yml"
                     LOG.warning(
-                        'Unable to update resource type "%s", id "%s"',
+                        'Unable to update resource type "%s", id "%s", '
+                        "the update operation is not implemented for this resource. "
+                        "Please consider submitting a feature request at this URL: %s",
                         request.resource_type,
                         request.logical_resource_id,
+                        feature_request_url,
                     )
                     if request.previous_state is None:
                         # this is an issue with our update detection. We should never be in this state.
@@ -559,6 +567,8 @@ class ResourceProviderExecutor:
     @staticmethod
     def try_load_resource_provider(resource_type: str) -> ResourceProvider | None:
         # TODO: unify namespace of plugins
+        if resource_type and resource_type.startswith("Custom"):
+            resource_type = "AWS::CloudFormation::CustomResource"
 
         # 1. try to load pro resource provider
         # prioritise pro resource providers
@@ -573,7 +583,7 @@ class ResourceProviderExecutor:
                 LOG.warning(
                     "Failed to load PRO resource type %s as a ResourceProvider.",
                     resource_type,
-                    exc_info=LOG.isEnabledFor(logging.DEBUG),
+                    exc_info=LOG.isEnabledFor(logging.DEBUG) and config.CFN_VERBOSE_ERRORS,
                 )
 
         # 2. try to load community resource provider
@@ -588,7 +598,7 @@ class ResourceProviderExecutor:
                 LOG.warning(
                     "Failed to load community resource type %s as a ResourceProvider.",
                     resource_type,
-                    exc_info=LOG.isEnabledFor(logging.DEBUG),
+                    exc_info=LOG.isEnabledFor(logging.DEBUG) and config.CFN_VERBOSE_ERRORS,
                 )
 
         # we could not find the resource provider

localstack/services/cloudformation/resource_providers/aws_cloudformation_macro.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 (
@@ -15,12 +15,12 @@ from localstack.services.cloudformation.stores import get_cloudformation_store
 
 
 class CloudFormationMacroProperties(TypedDict):
-    FunctionName: Optional[str]
-    Name: Optional[str]
-    Description: Optional[str]
-    Id: Optional[str]
-    LogGroupName: Optional[str]
-    LogRoleARN: Optional[str]
+    FunctionName: str | None
+    Name: str | None
+    Description: str | None
+    Id: str | None
+    LogGroupName: str | None
+    LogRoleARN: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/cloudformation/resource_providers/aws_cloudformation_macro_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 CloudFormationMacroProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::CloudFormation::Macro"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.cloudformation.resource_providers.aws_cloudformation_macro import (