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

localstack/services/cloudformation/engine/parameters.py

@@ -19,7 +19,7 @@ Documentation extracted from AWS docs (https://docs.aws.amazon.com/AWSCloudForma
 """
 
 import logging
-from typing import Literal, Optional, TypedDict
+from typing import Literal, TypedDict
 
 from botocore.exceptions import ClientError
 
@@ -76,7 +76,7 @@ def resolve_parameters(
     :param old_parameters: The old parameters from the previous stack deployment, if available
     :return: a copy of new_parameters with resolved values
     """
-    resolved_parameters = dict()
+    resolved_parameters = {}
 
     # populate values for every parameter declared in the template
     for pm in parameter_declarations.values():
@@ -179,8 +179,8 @@ def convert_stack_parameters_to_dict(in_params: list[Parameter] | None) -> dict[
 class LegacyParameterProperties(TypedDict):
     Value: str
     ParameterType: str
-    ParameterValue: Optional[str]
-    ResolvedValue: Optional[str]
+    ParameterValue: str | None
+    ResolvedValue: str | None
 
 
 class LegacyParameter(TypedDict):

localstack/services/cloudformation/engine/template_deployer.py

@@ -4,7 +4,6 @@ import logging
 import re
 import traceback
 import uuid
-from typing import Optional
 
 from botocore.exceptions import ClientError
 
@@ -86,7 +85,7 @@ def get_attr_from_model_instance(
     attribute_name: str,
     resource_type: str,
     resource_id: str,
-    attribute_sub_name: Optional[str] = None,
+    attribute_sub_name: str | None = None,
 ) -> str:
     if resource["PhysicalResourceId"] == MOCK_REFERENCE:
         LOG.warning(
@@ -330,7 +329,7 @@ def _resolve_refs_recursively(
                 account_id, region_name, stack_name, resources, parameters, value["Ref"]
             )
             if ref is None:
-                msg = 'Unable to resolve Ref for resource "%s" (yet)' % value["Ref"]
+                msg = 'Unable to resolve Ref for resource "{}" (yet)'.format(value["Ref"])
                 LOG.debug("%s - %s", msg, resources.get(value["Ref"]) or set(resources.keys()))
 
                 raise DependencyNotYetSatisfied(resource_ids=value["Ref"], message=msg)
@@ -451,7 +450,7 @@ def _resolve_refs_recursively(
                     raise DependencyNotYetSatisfied(
                         resource_ids=key, message=f"Could not resolve {val} to terminal value type"
                     )
-                result = result.replace("${%s}" % key, str(resolved_val))
+                result = result.replace(f"${{{key}}}", str(resolved_val))
 
             # resolve placeholders
             result = resolve_placeholders_in_string(
@@ -1029,7 +1028,7 @@ class TemplateDeployer:
             stack.set_resource_status(resource_id, f"{action}_IN_PROGRESS")
 
     def get_change_config(
-        self, action: str, resource: dict, change_set_id: Optional[str] = None
+        self, action: str, resource: dict, change_set_id: str | None = None
     ) -> ChangeConfig:
         result = ChangeConfig(
             **{
@@ -1105,10 +1104,10 @@ class TemplateDeployer:
         existing_stack,
         new_stack,
         # TODO: remove initialize argument from here, and determine action based on resource status
-        initialize: Optional[bool] = False,
+        initialize: bool | None = False,
         change_set_id=None,
-        append_to_changeset: Optional[bool] = False,
-        filter_unchanged_resources: Optional[bool] = False,
+        append_to_changeset: bool | None = False,
+        filter_unchanged_resources: bool | None = False,
     ) -> list[ChangeConfig]:
         old_resources = existing_stack.template["Resources"]
         new_resources = new_stack.template["Resources"]
@@ -1140,9 +1139,9 @@ class TemplateDeployer:
         self,
         existing_stack: Stack,
         new_stack: StackChangeSet,
-        change_set_id: Optional[str] = None,
-        initialize: Optional[bool] = False,
-        action: Optional[str] = None,
+        change_set_id: str | None = None,
+        initialize: bool | None = False,
+        action: str | None = None,
     ):
         old_resources = existing_stack.template["Resources"]
         new_resources = new_stack.template["Resources"]
@@ -1201,7 +1200,7 @@ class TemplateDeployer:
         self,
         changes: list[ChangeConfig],
         stack: Stack,
-        action: Optional[str] = None,
+        action: str | None = None,
         new_stack=None,
     ):
         def _run(*args):
@@ -1480,10 +1479,11 @@ class TemplateDeployer:
                         # correct order yet.
                         continue
                     case OperationStatus.FAILED:
-                        LOG.exception(
+                        LOG.error(
                             "Failed to delete resource with id %s. Reason: %s",
                             resource_id,
                             event.message or "unknown",
+                            exc_info=LOG.isEnabledFor(logging.DEBUG),
                         )
                     case OperationStatus.IN_PROGRESS:
                         # the resource provider executor should not return this state, so
@@ -1495,10 +1495,11 @@ class TemplateDeployer:
                         raise Exception(f"Use of unsupported status found: {other_status}")
 
             except Exception as e:
-                LOG.exception(
+                LOG.error(
                     "Failed to delete resource with id %s. Final exception: %s",
                     resource_id,
                     e,
+                    exc_info=LOG.isEnabledFor(logging.DEBUG),
                 )
 
         # update status

localstack/services/cloudformation/engine/template_utils.py

@@ -322,18 +322,40 @@ def resolve_condition(
                 case "Fn::Select":
                     index = v[0]
                     options = v[1]
-                    for i, option in enumerate(options):
-                        if isinstance(option, dict):
-                            options[i] = resolve_condition(
-                                account_id,
-                                region_name,
-                                option,
-                                conditions,
-                                parameters,
-                                mappings,
-                                stack_name,
-                            )
-                    return options[index]
+
+                    if isinstance(options, dict):
+                        options = resolve_condition(
+                            account_id,
+                            region_name,
+                            options,
+                            conditions,
+                            parameters,
+                            mappings,
+                            stack_name,
+                        )
+
+                    if isinstance(options, list):
+                        for i, option in enumerate(options):
+                            if isinstance(option, dict):
+                                options[i] = resolve_condition(
+                                    account_id,
+                                    region_name,
+                                    option,
+                                    conditions,
+                                    parameters,
+                                    mappings,
+                                    stack_name,
+                                )
+
+                        return options[index]
+
+                    if index != 0:
+                        raise Exception(
+                            f"Template error: Fn::Select  cannot select nonexistent value at index {index}"
+                        )
+
+                    return options
+
                 case "Fn::Sub":
                     # we can assume anything in there is a ref
                     if isinstance(v, str):

localstack/services/cloudformation/engine/transformers.py

@@ -3,9 +3,10 @@ import json
 import logging
 import os
 import re
+from collections.abc import Callable
 from copy import deepcopy
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, Optional, Type, Union
+from typing import Any
 
 import boto3
 from botocore.exceptions import ClientError
@@ -13,6 +14,7 @@ from samtranslator.translator.transform import transform as transform_sam
 
 from localstack.aws.api import CommonServiceException
 from localstack.aws.connect import connect_to
+from localstack.services.cloudformation.engine.parameters import StackParameter
 from localstack.services.cloudformation.engine.policy_loader import create_policy_loader
 from localstack.services.cloudformation.engine.template_deployer import resolve_refs_recursively
 from localstack.services.cloudformation.engine.validations import ValidationError
@@ -27,7 +29,7 @@ SERVERLESS_TRANSFORM = "AWS::Serverless-2016-10-31"
 EXTENSIONS_TRANSFORM = "AWS::LanguageExtensions"
 SECRETSMANAGER_TRANSFORM = "AWS::SecretsManager-2020-07-23"
 
-TransformResult = Union[dict, str]
+TransformResult = dict | str
 
 
 @dataclass
@@ -38,7 +40,7 @@ class ResolveRefsRecursivelyContext:
     resources: dict
     mappings: dict
     conditions: dict
-    parameters: dict
+    parameters: dict[str, StackParameter]
 
     def resolve(self, value: Any) -> Any:
         return resolve_refs_recursively(
@@ -83,7 +85,7 @@ class AwsIncludeTransformer(Transformer):
 
 
 # maps transformer names to implementing classes
-transformers: Dict[str, Type] = {"AWS::Include": AwsIncludeTransformer}
+transformers: dict[str, type] = {"AWS::Include": AwsIncludeTransformer}
 
 
 def apply_intrinsic_transformations(
@@ -256,10 +258,11 @@ def execute_macro(
     formatted_stack_parameters = {}
     for key, value in stack_parameters.items():
         # TODO: we want to support other types of parameters
-        if value.get("ParameterType") == "CommaDelimitedList":
-            formatted_stack_parameters[key] = value.get("ParameterValue").split(",")
+        parameter_value = value.get("ParameterValue")
+        if value.get("ParameterType") == "CommaDelimitedList" and isinstance(parameter_value, str):
+            formatted_stack_parameters[key] = parameter_value.split(",")
         else:
-            formatted_stack_parameters[key] = value.get("ParameterValue")
+            formatted_stack_parameters[key] = parameter_value
 
     transformation_id = f"{account_id}::{macro['Name']}"
     event = {
@@ -449,7 +452,7 @@ def expand_fn_foreach(
 
 def apply_serverless_transformation(
     account_id: str, region_name: str, parsed_template: dict, template_parameters: dict
-) -> Optional[str]:
+) -> str | None:
     """only returns string when parsing SAM template, otherwise None"""
     # TODO: we might also want to override the access key ID to account ID
     region_before = os.environ.get("AWS_DEFAULT_REGION")

localstack/services/cloudformation/engine/types.py

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Optional, TypedDict
+from collections.abc import Callable
+from typing import Any, TypedDict
 
 # ---------------------
 # TYPES
@@ -25,16 +26,16 @@ class FuncDetailsValue(TypedDict):
     # - stack_name
     # - resources
     # - resource_id
-    parameters: Optional[ResourceDefinition | Callable[[dict, str, list[dict], str], dict]]
+    parameters: ResourceDefinition | Callable[[dict, str, list[dict], str], dict] | None
     """arguments to the function, or a function that generates the arguments to the function"""
     # Callable here takes the arguments
     # - result
     # - resource_id
     # - resources
     # - resource_type
-    result_handler: Optional[Callable[[dict, str, list[dict], str], None]]
+    result_handler: Callable[[dict, str, list[dict], str], None] | None
     """Take the result of the operation and patch the state of the resources, yuck..."""
-    types: Optional[dict[str, Callable]]
+    types: dict[str, Callable] | None
     """Possible type conversions"""