localstack-core 4.2.1.dev38__tar.gz → 4.2.1.dev40__tar.gz

{localstack_core-4.2.1.dev38/localstack-core/localstack_core.egg-info → localstack_core-4.2.1.dev40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: localstack-core
-Version: 4.2.1.dev38
+Version: 4.2.1.dev40
 Summary: The core library and runtime of LocalStack
 Author-email: LocalStack Contributors <info@localstack.cloud>
 Project-URL: Homepage, https://localstack.cloud
@@ -31,8 +31,8 @@ Requires-Dist: requests>=2.20.0
 Requires-Dist: semver>=2.10
 Requires-Dist: tailer>=0.4.1
 Provides-Extra: base-runtime
-Requires-Dist: boto3==1.36.21; extra == "base-runtime"
-Requires-Dist: botocore==1.36.21; extra == "base-runtime"
+Requires-Dist: boto3==1.37.11; extra == "base-runtime"
+Requires-Dist: botocore==1.37.11; extra == "base-runtime"
 Requires-Dist: awscrt>=0.13.14; extra == "base-runtime"
 Requires-Dist: cbor2>=5.5.0; extra == "base-runtime"
 Requires-Dist: dnspython>=1.16.0; extra == "base-runtime"

{localstack_core-4.2.1.dev38 → localstack_core-4.2.1.dev40}/localstack-core/localstack/aws/api/ec2/__init__.py

@@ -353,6 +353,7 @@ VolumeId = str
 VolumeIdWithResolver = str
 VpcBlockPublicAccessExclusionId = str
 VpcCidrAssociationId = str
+VpcEncryptionControlId = str
 VpcEndpointId = str
 VpcEndpointServiceId = str
 VpcFlowLogId = str
@@ -3081,6 +3082,11 @@ class ServiceConnectivityType(StrEnum):
     ipv6 = "ipv6"
 
 
+class ServiceManaged(StrEnum):
+    alb = "alb"
+    nlb = "nlb"
+
+
 class ServiceState(StrEnum):
     Pending = "Pending"
     Available = "Available"
@@ -3606,6 +3612,28 @@ class VpcCidrBlockStateCode(StrEnum):
     failed = "failed"
 
 
+class VpcEncryptionControlExclusionState(StrEnum):
+    enabling = "enabling"
+    enabled = "enabled"
+    disabling = "disabling"
+    disabled = "disabled"
+
+
+class VpcEncryptionControlMode(StrEnum):
+    monitor = "monitor"
+    enforce = "enforce"
+
+
+class VpcEncryptionControlState(StrEnum):
+    enforce_in_progress = "enforce-in-progress"
+    monitor_in_progress = "monitor-in-progress"
+    enforce_failed = "enforce-failed"
+    monitor_failed = "monitor-failed"
+    deleting = "deleting"
+    deleted = "deleted"
+    available = "available"
+
+
 class VpcEndpointType(StrEnum):
     Interface = "Interface"
     Gateway = "Gateway"
@@ -4331,6 +4359,7 @@ class Address(TypedDict, total=False):
     CustomerOwnedIp: Optional[String]
     CustomerOwnedIpv4Pool: Optional[String]
     CarrierIp: Optional[String]
+    ServiceManaged: Optional[ServiceManaged]
     InstanceId: Optional[String]
     PublicIp: Optional[String]
 
@@ -5308,6 +5337,7 @@ class AvailabilityZone(TypedDict, total=False):
     ZoneType: Optional[String]
     ParentZoneName: Optional[String]
     ParentZoneId: Optional[String]
+    GroupLongName: Optional[String]
     State: Optional[AvailabilityZoneState]
 
 
@@ -5403,6 +5433,27 @@ BlockDeviceMappingList = List[BlockDeviceMapping]
 BlockDeviceMappingRequestList = List[BlockDeviceMapping]
 
 
+class EbsBlockDeviceResponse(TypedDict, total=False):
+    Encrypted: Optional[Boolean]
+    DeleteOnTermination: Optional[Boolean]
+    Iops: Optional[Integer]
+    Throughput: Optional[Integer]
+    KmsKeyId: Optional[KmsKeyId]
+    SnapshotId: Optional[SnapshotId]
+    VolumeSize: Optional[Integer]
+    VolumeType: Optional[VolumeType]
+
+
+class BlockDeviceMappingResponse(TypedDict, total=False):
+    DeviceName: Optional[String]
+    VirtualName: Optional[String]
+    Ebs: Optional[EbsBlockDeviceResponse]
+    NoDevice: Optional[String]
+
+
+BlockDeviceMappingResponseList = List[BlockDeviceMappingResponse]
+
+
 class BlockPublicAccessStates(TypedDict, total=False):
     InternetGatewayBlockMode: Optional[BlockPublicAccessMode]
 
@@ -6242,6 +6293,7 @@ class CopyImageRequest(ServiceRequest):
     DestinationOutpostArn: Optional[String]
     CopyImageTags: Optional[Boolean]
     TagSpecifications: Optional[TagSpecificationList]
+    SnapshotCopyCompletionDurationMinutes: Optional[Long]
     DryRun: Optional[Boolean]
 
 
@@ -6511,6 +6563,29 @@ class CreateDefaultVpcRequest(ServiceRequest):
     DryRun: Optional[Boolean]
 
 
+class VpcEncryptionControlExclusion(TypedDict, total=False):
+    State: Optional[VpcEncryptionControlExclusionState]
+    StateMessage: Optional[String]
+
+
+class VpcEncryptionControlExclusions(TypedDict, total=False):
+    InternetGateway: Optional[VpcEncryptionControlExclusion]
+    EgressOnlyInternetGateway: Optional[VpcEncryptionControlExclusion]
+    NatGateway: Optional[VpcEncryptionControlExclusion]
+    VirtualPrivateGateway: Optional[VpcEncryptionControlExclusion]
+    VpcPeering: Optional[VpcEncryptionControlExclusion]
+
+
+class VpcEncryptionControl(TypedDict, total=False):
+    VpcId: Optional[VpcId]
+    VpcEncryptionControlId: Optional[VpcEncryptionControlId]
+    Mode: Optional[VpcEncryptionControlMode]
+    State: Optional[VpcEncryptionControlState]
+    StateMessage: Optional[String]
+    ResourceExclusions: Optional[VpcEncryptionControlExclusions]
+    Tags: Optional[TagList]
+
+
 VpcCidrBlockAssociationSet = List[VpcCidrBlockAssociation]
 VpcIpv6CidrBlockAssociationSet = List[VpcIpv6CidrBlockAssociation]
 
@@ -6521,6 +6596,7 @@ class Vpc(TypedDict, total=False):
     Ipv6CidrBlockAssociationSet: Optional[VpcIpv6CidrBlockAssociationSet]
     CidrBlockAssociationSet: Optional[VpcCidrBlockAssociationSet]
     IsDefault: Optional[Boolean]
+    EncryptionControl: Optional[VpcEncryptionControl]
     Tags: Optional[TagList]
     BlockPublicAccessStates: Optional[BlockPublicAccessStates]
     VpcId: Optional[String]
@@ -6674,6 +6750,7 @@ class FleetLaunchTemplateOverrides(TypedDict, total=False):
     Placement: Optional[PlacementResponse]
     InstanceRequirements: Optional[InstanceRequirements]
     ImageId: Optional[ImageId]
+    BlockDeviceMappings: Optional[BlockDeviceMappingResponseList]
 
 
 class FleetLaunchTemplateSpecification(TypedDict, total=False):
@@ -6775,6 +6852,27 @@ class InstanceRequirementsRequest(TypedDict, total=False):
     BaselinePerformanceFactors: Optional[BaselinePerformanceFactorsRequest]
 
 
+class FleetEbsBlockDeviceRequest(TypedDict, total=False):
+    Encrypted: Optional[Boolean]
+    DeleteOnTermination: Optional[Boolean]
+    Iops: Optional[Integer]
+    Throughput: Optional[Integer]
+    KmsKeyId: Optional[KmsKeyId]
+    SnapshotId: Optional[SnapshotId]
+    VolumeSize: Optional[Integer]
+    VolumeType: Optional[VolumeType]
+
+
+class FleetBlockDeviceMappingRequest(TypedDict, total=False):
+    DeviceName: Optional[String]
+    VirtualName: Optional[String]
+    Ebs: Optional[FleetEbsBlockDeviceRequest]
+    NoDevice: Optional[String]
+
+
+FleetBlockDeviceMappingRequestList = List[FleetBlockDeviceMappingRequest]
+
+
 class Placement(TypedDict, total=False):
     Affinity: Optional[String]
     GroupName: Optional[PlacementGroupName]
@@ -6795,8 +6893,9 @@ class FleetLaunchTemplateOverridesRequest(TypedDict, total=False):
     WeightedCapacity: Optional[Double]
     Priority: Optional[Double]
     Placement: Optional[Placement]
+    BlockDeviceMappings: Optional[FleetBlockDeviceMappingRequestList]
     InstanceRequirements: Optional[InstanceRequirementsRequest]
-    ImageId: Optional[ImageId]
+    ImageId: Optional[String]
 
 
 FleetLaunchTemplateOverridesListRequest = List[FleetLaunchTemplateOverridesRequest]
@@ -10669,6 +10768,10 @@ class DeregisterImageRequest(ServiceRequest):
     DryRun: Optional[Boolean]
 
 
+class DeregisterImageResult(TypedDict, total=False):
+    pass
+
+
 InstanceTagKeySet = List[String]
 
 
@@ -20367,6 +20470,7 @@ class Ec2Api:
         destination_outpost_arn: String = None,
         copy_image_tags: Boolean = None,
         tag_specifications: TagSpecificationList = None,
+        snapshot_copy_completion_duration_minutes: Long = None,
         dry_run: Boolean = None,
         **kwargs,
     ) -> CopyImageResult:
@@ -22425,7 +22529,7 @@ class Ec2Api:
     @handler("DeregisterImage")
     def deregister_image(
         self, context: RequestContext, image_id: ImageId, dry_run: Boolean = None, **kwargs
-    ) -> None:
+    ) -> DeregisterImageResult:
         raise NotImplementedError
 
     @handler("DeregisterInstanceEventNotificationAttributes")

localstack_core-4.2.1.dev40/localstack-core/localstack/services/cloudformation/engine/v2/change_set_model.py

@@ -0,0 +1,404 @@
+from __future__ import annotations
+
+import abc
+import enum
+from itertools import zip_longest
+from typing import Any, Final, Generator, Optional, Union
+
+from typing_extensions import TypeVar
+
+T = TypeVar("T")
+
+
+class NothingType:
+    """A sentinel that denotes 'no value' (distinct from None)."""
+
+    _singleton = None
+    __slots__ = ()
+
+    def __new__(cls):
+        if cls._singleton is None:
+            cls._singleton = super().__new__(cls)
+        return cls._singleton
+
+    def __str__(self):
+        return repr(self)
+
+    def __repr__(self) -> str:
+        return "Nothing"
+
+
+Maybe = Union[T, NothingType]
+Nothing = NothingType()
+
+
+class ChangeType(enum.Enum):
+    UNCHANGED = "Unchanged"
+    CREATED = "Created"
+    MODIFIED = "Modified"
+    REMOVED = "Removed"
+
+    def __str__(self):
+        return self.value
+
+
+class ChangeSetEntity(abc.ABC):
+    change_type: Final[ChangeType]
+
+    def __init__(self, change_type: ChangeType):
+        self.change_type = change_type
+
+    def get_children(self) -> Generator[ChangeSetEntity]:
+        for child in self.__dict__.values():
+            yield from self._get_children_in(child)
+
+    @staticmethod
+    def _get_children_in(obj: Any) -> Generator[ChangeSetEntity]:
+        # TODO: could avoid the inductive logic here, and check for loops?
+        if isinstance(obj, ChangeSetEntity):
+            yield obj
+        elif isinstance(obj, list):
+            for item in obj:
+                yield from ChangeSetEntity._get_children_in(item)
+        elif isinstance(obj, dict):
+            for item in obj.values():
+                yield from ChangeSetEntity._get_children_in(item)
+
+    def __str__(self):
+        return f"({self.__class__.__name__}| {vars(self)}"
+
+    def __repr__(self):
+        return str(self)
+
+
+class ChangeSetNode(ChangeSetEntity, abc.ABC): ...
+
+
+class ChangeSetTerminal(ChangeSetEntity, abc.ABC): ...
+
+
+class NodeTemplate(ChangeSetNode):
+    resources: Final[NodeResources]
+
+    def __init__(self, change_type: ChangeType, resources: NodeResources):
+        super().__init__(change_type=change_type)
+        self.resources = resources
+
+
+class NodeResources(ChangeSetNode):
+    resources: Final[list[NodeResource]]
+
+    def __init__(self, change_type: ChangeType, resources: list[NodeResource]):
+        super().__init__(change_type=change_type)
+        self.resources = resources
+
+
+class NodeResource(ChangeSetNode):
+    name: Final[str]
+    type_: Final[ChangeSetTerminal]
+    properties: Final[NodeProperties]
+
+    def __init__(
+        self,
+        change_type: ChangeType,
+        name: str,
+        type_: ChangeSetTerminal,
+        properties: NodeProperties,
+    ):
+        super().__init__(change_type=change_type)
+        self.name = name
+        self.type_ = type_
+        self.properties = properties
+
+
+class NodeProperties(ChangeSetNode):
+    properties: Final[list[NodeProperty]]
+
+    def __init__(self, change_type: ChangeType, properties: list[NodeProperty]):
+        super().__init__(change_type=change_type)
+        self.properties = properties
+
+
+class NodeProperty(ChangeSetNode):
+    name: Final[str]
+    value: Final[ChangeSetEntity]
+
+    def __init__(self, change_type: ChangeType, name: str, value: ChangeSetEntity):
+        super().__init__(change_type=change_type)
+        self.name = name
+        self.value = value
+
+
+class NodeObject(ChangeSetNode):
+    bindings: Final[dict[str, ChangeSetEntity]]
+
+    def __init__(self, change_type: ChangeType, bindings: dict[str, ChangeSetEntity]):
+        super().__init__(change_type=change_type)
+        self.bindings = bindings
+
+
+class NodeArray(ChangeSetNode):
+    array: Final[list[ChangeSetEntity]]
+
+    def __init__(self, change_type: ChangeType, array: list[ChangeSetEntity]):
+        super().__init__(change_type=change_type)
+        self.array = array
+
+
+class TerminalValue(ChangeSetTerminal, abc.ABC):
+    value: Final[Any]
+
+    def __init__(self, change_type: ChangeType, value: Any):
+        super().__init__(change_type=change_type)
+        self.value = value
+
+
+class TerminalValueModified(TerminalValue):
+    modified_value: Final[Any]
+
+    def __init__(self, value: Any, modified_value: Any):
+        super().__init__(change_type=ChangeType.MODIFIED, value=value)
+        self.modified_value = modified_value
+
+
+class TerminalValueCreated(TerminalValue):
+    def __init__(self, value: Any):
+        super().__init__(change_type=ChangeType.CREATED, value=value)
+
+
+class TerminalValueRemoved(TerminalValue):
+    def __init__(self, value: Any):
+        super().__init__(change_type=ChangeType.REMOVED, value=value)
+
+
+class TerminalValueUnchanged(TerminalValue):
+    def __init__(self, value: Any):
+        super().__init__(change_type=ChangeType.UNCHANGED, value=value)
+
+
+ResourcesKey: Final[str] = "Resources"
+PropertiesKey: Final[str] = "Properties"
+
+
+class ChangeSetModel:
+    # TODO: should this instead be generalised to work on "Stack" objects instead of just "Template"s?
+
+    # TODO: can probably improve the typehints to use CFN's 'language' eg. dict -> Template|Properties, etc.
+
+    # TODO: typechecks for key-value pairs?
+
+    _before_template: Final[Maybe[dict]]
+    _after_template: Final[Maybe[dict]]
+    _node_template: Final[NodeTemplate]
+
+    def __init__(self, before_template: Optional[dict], after_template: Optional[dict]):
+        self._before_template = before_template or Nothing
+        self._after_template = after_template or Nothing
+        self._node_template = self._model(
+            before_template=before_template, after_template=after_template
+        )
+
+    def get_update_model(self) -> NodeTemplate:
+        # TODO: rethink naming of this for outer utils
+        return self._node_template
+
+    def _visit_terminal_value(  # noqa
+        self, before_value: Maybe[Any], after_value: Maybe[Any]
+    ) -> TerminalValue:
+        if self._is_created(before=before_value, after=after_value):
+            return TerminalValueCreated(value=after_value)
+        if self._is_removed(before=before_value, after=after_value):
+            return TerminalValueRemoved(value=before_value)
+        if before_value == after_value:
+            return TerminalValueUnchanged(value=before_value)
+        return TerminalValueModified(value=before_value, modified_value=after_value)
+
+    def _visit_array(self, before_array: Maybe[list], after_array: Maybe[list]) -> NodeArray:
+        change_type = ChangeType.UNCHANGED
+        array: list[ChangeSetEntity] = list()
+        for before_value, after_value in zip_longest(before_array, after_array, fillvalue=Nothing):
+            value = self._visit_value(before_value=before_value, after_value=after_value)
+            array.append(value)
+            if value.change_type != ChangeType.UNCHANGED:
+                change_type = ChangeType.MODIFIED
+        return NodeArray(change_type=change_type, array=array)
+
+    def _visit_object(self, before_object: Maybe[dict], after_object: Maybe[dict]) -> NodeObject:
+        change_type = ChangeType.UNCHANGED
+        binding_names = self._keys_of(before_object, after_object)
+        bindings: dict[str, ChangeSetEntity] = dict()
+        for binding_name in binding_names:
+            # TODO: check the binding names for intrinsic functions and redirect.
+            before_value, after_value = self._sample_from(binding_name, before_object, after_object)
+            value = self._visit_value(before_value=before_value, after_value=after_value)
+            bindings[binding_name] = value
+            if value.change_type != ChangeType.UNCHANGED:
+                change_type = ChangeType.MODIFIED
+        return NodeObject(change_type=change_type, bindings=bindings)
+
+    def _visit_value(self, before_value: Maybe[Any], after_value: Maybe[Any]) -> ChangeSetEntity:
+        before_type = type(before_value)
+        after_type = type(after_value)
+
+        if self._is_created(before=before_value, after=after_value):
+            return TerminalValueCreated(value=after_value)
+        if self._is_removed(before=before_value, after=after_value):
+            return TerminalValueRemoved(value=before_value)
+
+        # Case: update on the same type.
+        if before_type == after_type:
+            if self._is_terminal(value=before_value):
+                value = self._visit_terminal_value(
+                    before_value=before_value, after_value=after_value
+                )
+            elif self._is_object(value=before_value):
+                value = self._visit_object(before_object=before_value, after_object=after_value)
+            elif self._is_array(value=before_value):
+                value = self._visit_array(before_array=before_value, after_array=after_value)
+            else:
+                raise RuntimeError(f"Unsupported type {before_type}")
+            return value
+        # Case: update to new type.
+        else:
+            return TerminalValueModified(value=before_value, modified_value=after_value)
+
+    def _visit_property(
+        self, property_name: str, before_property: Maybe[Any], after_property: Maybe[Any]
+    ) -> NodeProperty:
+        if self._is_created(before=before_property, after=after_property):
+            return NodeProperty(
+                change_type=ChangeType.CREATED,
+                name=property_name,
+                value=TerminalValueCreated(value=after_property),
+            )
+        if self._is_removed(before=before_property, after=after_property):
+            return NodeProperty(
+                change_type=ChangeType.REMOVED,
+                name=property_name,
+                value=TerminalValueRemoved(value=before_property),
+            )
+        value = self._visit_value(before_value=before_property, after_value=after_property)
+        return NodeProperty(change_type=value.change_type, name=property_name, value=value)
+
+    def _visit_properties(
+        self, before_properties: Maybe[dict], after_properties: Maybe[dict]
+    ) -> NodeProperties:
+        # TODO: double check we are sure not to have this be a NodeObject
+        property_names: set[str] = self._keys_of(before_properties, after_properties)
+        properties: list[NodeProperty] = list()
+        change_type = ChangeType.UNCHANGED
+        for property_name in property_names:
+            before_property, after_property = self._sample_from(
+                property_name, before_properties, after_properties
+            )
+            property_ = self._visit_property(
+                property_name=property_name,
+                before_property=before_property,
+                after_property=after_property,
+            )
+            properties.append(property_)
+            # TODO: compute the properties change type properly.
+            if property_.change_type != ChangeType.UNCHANGED:
+                change_type = change_type.MODIFIED
+        return NodeProperties(change_type=change_type, properties=properties)
+
+    def _visit_resource(
+        self, resource_name: str, before_resource: Maybe[dict], after_resource: Maybe[dict]
+    ) -> NodeResource:
+        if self._is_created(before=before_resource, after=after_resource):
+            change_type = ChangeType.CREATED
+        elif self._is_removed(before=before_resource, after=after_resource):
+            change_type = ChangeType.REMOVED
+        else:
+            change_type = ChangeType.UNCHANGED
+
+        before_properties, after_properties = self._sample_from(
+            PropertiesKey, before_resource, after_resource
+        )
+        properties = self._visit_properties(
+            before_properties=before_properties, after_properties=after_properties
+        )
+
+        if change_type == ChangeType.UNCHANGED and properties.change_type != ChangeType.UNCHANGED:
+            change_type = ChangeType.MODIFIED
+
+        return NodeResource(
+            change_type=change_type,
+            name=resource_name,
+            # TODO: investigate behaviour with type changes, for now this is filler code.
+            type_=TerminalValueUnchanged(value="<Type>"),
+            properties=properties,
+        )
+
+    def _visit_resources(
+        self, before_resources: Maybe[dict], after_resources: Maybe[dict]
+    ) -> NodeResources:
+        # TODO: investigate type changes behavior.
+        change_type = ChangeType.UNCHANGED
+        resources: list[NodeResource] = list()
+        resource_names = self._keys_of(before_resources, after_resources)
+        for resource_name in resource_names:
+            before_resource, after_resource = self._sample_from(
+                resource_name, before_resources, after_resources
+            )
+            resource = self._visit_resource(
+                resource_name=resource_name,
+                before_resource=before_resource,
+                after_resource=after_resource,
+            )
+            resources.append(resource)
+            # TODO: compute the properties change type properly.
+            if resource.change_type != ChangeType.UNCHANGED:
+                change_type = ChangeType.MODIFIED
+        return NodeResources(change_type=change_type, resources=resources)
+
+    def _model(self, before_template: Maybe[dict], after_template: Maybe[dict]) -> NodeTemplate:
+        # TODO: visit other child types
+        before_resources, after_resources = self._sample_from(
+            ResourcesKey, before_template, after_template
+        )
+        resources = self._visit_resources(
+            before_resources=before_resources, after_resources=after_resources
+        )
+        # TODO: what is a change type for templates?
+        return NodeTemplate(change_type=resources.change_type, resources=resources)
+
+    @staticmethod
+    def _sample_from(key: str, *objects: Maybe[dict]) -> Maybe[Any]:
+        results = list()
+        for obj in objects:
+            # TODO: raise errors if not dict
+            if not isinstance(obj, NothingType):
+                results.append(obj.get(key, Nothing))
+            else:
+                results.append(obj)
+        return results[0] if len(objects) == 1 else tuple(results)
+
+    @staticmethod
+    def _keys_of(*objects: Maybe[dict]) -> set[str]:
+        keys: set[str] = set()
+        for obj in objects:
+            # TODO: raise errors if not dict
+            if isinstance(obj, dict):
+                keys.update(obj.keys())
+        return set(keys)
+
+    @staticmethod
+    def _is_terminal(value: Any) -> bool:
+        return type(value) in {int, float, bool, str, None}
+
+    @staticmethod
+    def _is_object(value: Any) -> bool:
+        return isinstance(value, dict)
+
+    @staticmethod
+    def _is_array(value: Any) -> bool:
+        return isinstance(value, list)
+
+    @staticmethod
+    def _is_created(before: Maybe[Any], after: Maybe[Any]) -> bool:
+        return isinstance(before, NothingType) and not isinstance(after, NothingType)
+
+    @staticmethod
+    def _is_removed(before: Maybe[Any], after: Maybe[Any]) -> bool:
+        return not isinstance(before, NothingType) and isinstance(after, NothingType)