localstack-core 4.6.1.dev74__py3-none-any.whl → 4.10.1.dev7__py3-none-any.whl

localstack/services/dynamodb/utils.py

@@ -1,7 +1,6 @@
 import logging
 import re
 from binascii import crc32
-from typing import Dict, List, Optional
 
 from boto3.dynamodb.types import TypeDeserializer, TypeSerializer
 from cachetools import TTLCache
@@ -61,7 +60,7 @@ def get_ddb_access_key(account_id: str, region_name: str) -> str:
 class ItemSet:
     """Represents a set of items and provides utils to find individual items in the set"""
 
-    def __init__(self, items: List[Dict], key_schema: List[Dict]):
+    def __init__(self, items: list[dict], key_schema: list[dict]):
         self.items_list = items
         self.key_schema = key_schema
         self._build_dict()
@@ -71,11 +70,11 @@ class ItemSet:
         for item in self.items_list:
             self.items_dict[self._hashable_key(item)] = item
 
-    def _hashable_key(self, item: Dict):
+    def _hashable_key(self, item: dict):
         keys = SchemaExtractor.extract_keys_for_schema(item=item, key_schema=self.key_schema)
         return canonical_json(keys)
 
-    def find_item(self, item: Dict) -> Optional[Dict]:
+    def find_item(self, item: dict) -> dict | None:
         key = self._hashable_key(item)
         return self.items_dict.get(key)
 
@@ -83,13 +82,13 @@ class ItemSet:
 class SchemaExtractor:
     @classmethod
     def extract_keys(
-        cls, item: Dict, table_name: str, account_id: str, region_name: str
-    ) -> Optional[Dict]:
+        cls, item: dict, table_name: str, account_id: str, region_name: str
+    ) -> dict | None:
         key_schema = cls.get_key_schema(table_name, account_id, region_name)
         return cls.extract_keys_for_schema(item, key_schema)
 
     @classmethod
-    def extract_keys_for_schema(cls, item: Dict, key_schema: List[Dict]):
+    def extract_keys_for_schema(cls, item: dict, key_schema: list[dict]):
         result = {}
         for key in key_schema:
             attr_name = key["AttributeName"]
@@ -104,10 +103,10 @@ class SchemaExtractor:
     @classmethod
     def get_key_schema(
         cls, table_name: str, account_id: str, region_name: str
-    ) -> Optional[List[Dict]]:
+    ) -> list[dict] | None:
         from localstack.services.dynamodb.provider import get_store
 
-        table_definitions: Dict = get_store(
+        table_definitions: dict = get_store(
             account_id=account_id,
             region_name=region_name,
         ).table_definitions
@@ -169,12 +168,12 @@ class ItemFinder:
 
     @staticmethod
     def find_existing_item(
-        put_item: Dict,
+        put_item: dict,
         table_name: str,
         account_id: str,
         region_name: str,
         endpoint_url: str,
-    ) -> Optional[AttributeMap]:
+    ) -> AttributeMap | None:
         from localstack.services.dynamodb.provider import ValidationException
 
         ddb_client = ItemFinder.get_ddb_local_client(account_id, region_name, endpoint_url)
@@ -273,7 +272,7 @@ class ItemFinder:
     @classmethod
     def list_existing_items_for_statement(
         cls, partiql_statement: str, account_id: str, region_name: str, endpoint_url: str
-    ) -> List:
+    ) -> list:
         table_name = extract_table_name_from_partiql_update(partiql_statement)
         if not table_name:
             return []
@@ -288,7 +287,7 @@ class ItemFinder:
     @staticmethod
     def get_all_table_items(
         account_id: str, region_name: str, table_name: str, endpoint_url: str
-    ) -> List:
+    ) -> list:
         ddb_client = ItemFinder.get_ddb_local_client(account_id, region_name, endpoint_url)
         dynamodb_kwargs = {"TableName": table_name}
         all_items = list_all_resources(
@@ -300,7 +299,7 @@ class ItemFinder:
         return all_items
 
 
-def extract_table_name_from_partiql_update(statement: str) -> Optional[str]:
+def extract_table_name_from_partiql_update(statement: str) -> str | None:
     regex = r"^\s*(UPDATE|INSERT\s+INTO|DELETE\s+FROM)\s+([^\s]+).*"
     match = re.match(regex, statement, flags=re.IGNORECASE | re.MULTILINE)
     return match and match.group(2)

localstack/services/dynamodb/v2/provider.py

@@ -9,7 +9,6 @@ import time
 from contextlib import contextmanager
 from datetime import datetime
 from operator import itemgetter
-from typing import Dict, Optional
 
 import requests
 import werkzeug
@@ -41,6 +40,8 @@ from localstack.aws.api.dynamodb import (
     DeleteRequest,
     DeleteTableOutput,
     DescribeContinuousBackupsOutput,
+    DescribeContributorInsightsInput,
+    DescribeContributorInsightsOutput,
     DescribeGlobalTableOutput,
     DescribeKinesisStreamingDestinationOutput,
     DescribeTableOutput,
@@ -340,7 +341,7 @@ class ExpiredItemsWorker:
     def __init__(self) -> None:
         super().__init__()
         self.scheduler = Scheduler()
-        self.thread: Optional[FuncThread] = None
+        self.thread: FuncThread | None = None
         self.mutex = threading.RLock()
 
     def start(self):
@@ -559,6 +560,9 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             if "NumberOfDecreasesToday" not in table_description["ProvisionedThroughput"]:
                 table_description["ProvisionedThroughput"]["NumberOfDecreasesToday"] = 0
 
+        if "WarmThroughput" in table_description:
+            table_description["WarmThroughput"]["Status"] = "UPDATING"
+
         tags = table_definitions.pop("Tags", [])
         if tags:
             get_store(context.account_id, context.region).TABLE_TAGS[table_arn] = {
@@ -576,6 +580,13 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
     ) -> DeleteTableOutput:
         global_table_region = self.get_global_table_region(context, table_name)
 
+        self.ensure_table_exists(
+            context.account_id,
+            global_table_region,
+            table_name,
+            error_message=f"Requested resource not found: Table: {table_name} not found",
+        )
+
         # Limitation note: On AWS, for a replicated table, if the source table is deleted, the replicated tables continue to exist.
         # This is not the case for LocalStack, where all replicated tables will also be removed if source is deleted.
 
@@ -607,7 +618,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         store = get_store(context.account_id, context.region)
 
         # Update replication details
-        replicas: Dict[RegionName, ReplicaDescription] = store.REPLICAS.get(table_name, {})
+        replicas: dict[RegionName, ReplicaDescription] = store.REPLICAS.get(table_name, {})
 
         replica_description_list = []
 
@@ -635,6 +646,9 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 table_description["TableClassSummary"] = {
                     "TableClass": table_definitions["TableClass"]
                 }
+            if warm_throughput := table_definitions.get("WarmThroughput"):
+                table_description["WarmThroughput"] = warm_throughput.copy()
+                table_description["WarmThroughput"].setdefault("Status", "ACTIVE")
 
         if "GlobalSecondaryIndexes" in table_description:
             for gsi in table_description["GlobalSecondaryIndexes"]:
@@ -647,6 +661,17 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 # Terraform depends on this parity for update operations
                 gsi["ProvisionedThroughput"] = default_values | gsi.get("ProvisionedThroughput", {})
 
+        # Set defaults for warm throughput
+        if "WarmThroughput" not in table_description:
+            billing_mode = table_definitions.get("BillingMode") if table_definitions else None
+            table_description["WarmThroughput"] = {
+                "ReadUnitsPerSecond": 12000 if billing_mode == "PAY_PER_REQUEST" else 5,
+                "WriteUnitsPerSecond": 4000 if billing_mode == "PAY_PER_REQUEST" else 5,
+            }
+        table_description["WarmThroughput"]["Status"] = (
+            table_description.get("TableStatus") or "ACTIVE"
+        )
+
         return DescribeTableOutput(
             Table=select_from_typed_dict(TableDescription, table_description)
         )
@@ -676,7 +701,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 store = get_store(context.account_id, global_table_region)
 
                 # Dict with source region to set of replicated regions
-                replicas: Dict[RegionName, ReplicaDescription] = store.REPLICAS.get(table_name, {})
+                replicas: dict[RegionName, ReplicaDescription] = store.REPLICAS.get(table_name, {})
 
                 for replica_update in replica_updates:
                     for key, details in replica_update.items():
@@ -758,6 +783,22 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
 
         return response
 
+    #
+    # Contributor Insights
+    #
+
+    @handler("DescribeContributorInsights", expand=False)
+    def describe_contributor_insights(
+        self,
+        context: RequestContext,
+        describe_contributor_insights_input: DescribeContributorInsightsInput,
+    ) -> DescribeContributorInsightsOutput:
+        return DescribeContributorInsightsOutput(
+            TableName=describe_contributor_insights_input["TableName"],
+            IndexName=describe_contributor_insights_input.get("IndexName"),
+            ContributorInsightsStatus="DISABLED",
+        )
+
     #
     # Item ops
     #
@@ -1036,7 +1077,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         replication_group: ReplicaList,
         **kwargs,
     ) -> CreateGlobalTableOutput:
-        global_tables: Dict = get_store(context.account_id, context.region).GLOBAL_TABLES
+        global_tables: dict = get_store(context.account_id, context.region).GLOBAL_TABLES
         if global_table_name in global_tables:
             raise GlobalTableAlreadyExistsException("Global table with this name already exists")
         replication_group = [grp.copy() for grp in replication_group or []]
@@ -1410,7 +1451,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         return context.region
 
     @staticmethod
-    def prepare_request_headers(headers: Dict, account_id: str, region_name: str):
+    def prepare_request_headers(headers: dict, account_id: str, region_name: str):
         """
         Modify the Credentials field of Authorization header to achieve namespacing in DynamoDBLocal.
         """
@@ -1427,7 +1468,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
             flags=re.IGNORECASE,
         )
 
-    def fix_consumed_capacity(self, request: Dict, result: Dict):
+    def fix_consumed_capacity(self, request: dict, result: dict):
         # make sure we append 'ConsumedCapacity', which is properly
         # returned by dynalite, but not by AWS's DynamoDBLocal
         table_name = request.get("TableName")

localstack/services/dynamodbstreams/dynamodbstreams_api.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING
 
 from bson.json_util import dumps
 
@@ -206,7 +206,7 @@ def kinesis_shard_id(dynamodbstream_shard_id: str) -> str:
     return f"{shard_params[0]}-{shard_params[-1]}"
 
 
-def get_shard_id(stream: Dict, kinesis_shard_id: str) -> str:
+def get_shard_id(stream: dict, kinesis_shard_id: str) -> str:
     ddb_stream_shard_id = stream.get("shards_id_map", {}).get(kinesis_shard_id)
     if not ddb_stream_shard_id:
         ddb_stream_shard_id = shard_id(kinesis_shard_id)

localstack/services/dynamodbstreams/models.py

@@ -1,11 +1,9 @@
-from typing import Dict
-
 from localstack.services.stores import AccountRegionBundle, BaseStore, LocalAttribute
 
 
 class DynamoDbStreamsStore(BaseStore):
     # maps table names to DynamoDB stream descriptions
-    ddb_streams: Dict[str, dict] = LocalAttribute(default=dict)
+    ddb_streams: dict[str, dict] = LocalAttribute(default=dict)
 
 
 dynamodbstreams_stores = AccountRegionBundle("dynamodbstreams", DynamoDbStreamsStore)

localstack/services/ec2/patches.py

@@ -1,7 +1,7 @@
 import logging
-from typing import Optional
 
 from moto.ec2 import models as ec2_models
+from moto.ec2.models.vpcs import VPCEndPoint
 from moto.utilities.id_generator import Tags
 
 from localstack.services.ec2.exceptions import (
@@ -15,6 +15,8 @@ from localstack.utils.id_generator import (
     localstack_id,
 )
 from localstack.utils.patch import patch
+from localstack.utils.strings import short_uid
+from localstack.utils.urls import localstack_host
 
 LOG = logging.getLogger(__name__)
 
@@ -93,12 +95,31 @@ class SubnetIdentifier(ResourceIdentifier):
 
 
 def apply_patches():
+    @patch(ec2_models.vpcs.VPCBackend.create_vpc_endpoint)
+    def ec2_create_vpc_endpoint(
+        fn: ec2_models.VPCBackend.create_vpc_endpoint, self: ec2_models.VPCBackend, **kwargs
+    ) -> VPCEndPoint:
+        vpc_endpoint: VPCEndPoint = fn(self=self, **kwargs)
+
+        # moto returns the dns entries as `<vpc-id>.com.amazonaws.<region>.<service>`
+        # to keep the aws style `<vpc-id>.<service>.<region>.vpce.amazonaws.com` and ensure it can be routed
+        # by the individual services in LocalStack we will be creating the following entries:
+        # `<vpc-id>.<service>.<region>.vpce.<localstack host and port>`
+        if service_name := kwargs.get("service_name"):
+            ls_service_name = ".".join(service_name.split(".")[::-1]).replace(
+                "amazonaws.com", f"vpce.{localstack_host()}"
+            )
+            for dns_entry in vpc_endpoint.dns_entries or []:
+                dns_entry["dns_name"] = f"{vpc_endpoint.id}-{short_uid()}.{ls_service_name}"
+
+        return vpc_endpoint
+
     @patch(ec2_models.subnets.SubnetBackend.create_subnet)
     def ec2_create_subnet(
         fn: ec2_models.subnets.SubnetBackend.create_subnet,
         self: ec2_models.subnets.SubnetBackend,
         *args,
-        tags: Optional[dict[str, str]] = None,
+        tags: dict[str, str] | None = None,
         **kwargs,
     ):
         # Patch this method so that we can create a subnet with a specific "custom"
@@ -151,8 +172,8 @@ def apply_patches():
         self: ec2_models.security_groups.SecurityGroupBackend,
         name: str,
         *args,
-        vpc_id: Optional[str] = None,
-        tags: Optional[dict[str, str]] = None,
+        vpc_id: str | None = None,
+        tags: dict[str, str] | None = None,
         force: bool = False,
         **kwargs,
     ):
@@ -191,7 +212,7 @@ def apply_patches():
         self: ec2_models.vpcs.VPCBackend,
         cidr_block: str,
         *args,
-        tags: Optional[list[dict[str, str]]] = None,
+        tags: list[dict[str, str]] | None = None,
         is_default: bool = False,
         **kwargs,
     ):

localstack/services/ec2/provider.py

@@ -3,7 +3,7 @@ import json
 import logging
 import re
 from abc import ABC
-from datetime import datetime, timezone
+from datetime import UTC, datetime
 
 from botocore.parsers import ResponseParserError
 from moto.core.utils import camelcase_to_underscores, underscores_to_camelcase
@@ -173,13 +173,13 @@ class Ec2Provider(Ec2Api, ABC, ServiceLifecycleHook):
                 ReservedInstances(
                     AvailabilityZone="eu-central-1a",
                     Duration=2628000,
-                    End=datetime(2016, 6, 30, tzinfo=timezone.utc),
+                    End=datetime(2016, 6, 30, tzinfo=UTC),
                     FixedPrice=0.0,
                     InstanceCount=2,
                     InstanceType=InstanceType.t2_small,
                     ProductDescription=RIProductDescription.Linux_UNIX,
                     ReservedInstancesId=long_uid(),
-                    Start=datetime(2016, 1, 1, tzinfo=timezone.utc),
+                    Start=datetime(2016, 1, 1, tzinfo=UTC),
                     State=ReservedInstanceState.active,
                     UsagePrice=0.05,
                     CurrencyCode=CurrencyCodeValues.USD,

localstack/services/ec2/resource_providers/aws_ec2_dhcpoptions.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,18 +14,18 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class EC2DHCPOptionsProperties(TypedDict):
-    DhcpOptionsId: Optional[str]
-    DomainName: Optional[str]
-    DomainNameServers: Optional[list[str]]
-    NetbiosNameServers: Optional[list[str]]
-    NetbiosNodeType: Optional[int]
-    NtpServers: Optional[list[str]]
-    Tags: Optional[list[Tag]]
+    DhcpOptionsId: str | None
+    DomainName: str | None
+    DomainNameServers: list[str] | None
+    NetbiosNameServers: list[str] | None
+    NetbiosNodeType: int | None
+    NtpServers: list[str] | None
+    Tags: list[Tag] | None
 
 
 class Tag(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/ec2/resource_providers/aws_ec2_dhcpoptions_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 EC2DHCPOptionsProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::EC2::DHCPOptions"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.ec2.resource_providers.aws_ec2_dhcpoptions import (