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

localstack/services/dynamodb/resource_providers/aws_dynamodb_table.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,113 +14,113 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class DynamoDBTableProperties(TypedDict):
-    KeySchema: Optional[list[KeySchema] | dict]
-    Arn: Optional[str]
-    AttributeDefinitions: Optional[list[AttributeDefinition]]
-    BillingMode: Optional[str]
-    ContributorInsightsSpecification: Optional[ContributorInsightsSpecification]
-    DeletionProtectionEnabled: Optional[bool]
-    GlobalSecondaryIndexes: Optional[list[GlobalSecondaryIndex]]
-    ImportSourceSpecification: Optional[ImportSourceSpecification]
-    KinesisStreamSpecification: Optional[KinesisStreamSpecification]
-    LocalSecondaryIndexes: Optional[list[LocalSecondaryIndex]]
-    PointInTimeRecoverySpecification: Optional[PointInTimeRecoverySpecification]
-    ProvisionedThroughput: Optional[ProvisionedThroughput]
-    SSESpecification: Optional[SSESpecification]
-    StreamArn: Optional[str]
-    StreamSpecification: Optional[StreamSpecification]
-    TableClass: Optional[str]
-    TableName: Optional[str]
-    Tags: Optional[list[Tag]]
-    TimeToLiveSpecification: Optional[TimeToLiveSpecification]
+    KeySchema: list[KeySchema] | dict | None
+    Arn: str | None
+    AttributeDefinitions: list[AttributeDefinition] | None
+    BillingMode: str | None
+    ContributorInsightsSpecification: ContributorInsightsSpecification | None
+    DeletionProtectionEnabled: bool | None
+    GlobalSecondaryIndexes: list[GlobalSecondaryIndex] | None
+    ImportSourceSpecification: ImportSourceSpecification | None
+    KinesisStreamSpecification: KinesisStreamSpecification | None
+    LocalSecondaryIndexes: list[LocalSecondaryIndex] | None
+    PointInTimeRecoverySpecification: PointInTimeRecoverySpecification | None
+    ProvisionedThroughput: ProvisionedThroughput | None
+    SSESpecification: SSESpecification | None
+    StreamArn: str | None
+    StreamSpecification: StreamSpecification | None
+    TableClass: str | None
+    TableName: str | None
+    Tags: list[Tag] | None
+    TimeToLiveSpecification: TimeToLiveSpecification | None
 
 
 class AttributeDefinition(TypedDict):
-    AttributeName: Optional[str]
-    AttributeType: Optional[str]
+    AttributeName: str | None
+    AttributeType: str | None
 
 
 class KeySchema(TypedDict):
-    AttributeName: Optional[str]
-    KeyType: Optional[str]
+    AttributeName: str | None
+    KeyType: str | None
 
 
 class Projection(TypedDict):
-    NonKeyAttributes: Optional[list[str]]
-    ProjectionType: Optional[str]
+    NonKeyAttributes: list[str] | None
+    ProjectionType: str | None
 
 
 class ProvisionedThroughput(TypedDict):
-    ReadCapacityUnits: Optional[int]
-    WriteCapacityUnits: Optional[int]
+    ReadCapacityUnits: int | None
+    WriteCapacityUnits: int | None
 
 
 class ContributorInsightsSpecification(TypedDict):
-    Enabled: Optional[bool]
+    Enabled: bool | None
 
 
 class GlobalSecondaryIndex(TypedDict):
-    IndexName: Optional[str]
-    KeySchema: Optional[list[KeySchema]]
-    Projection: Optional[Projection]
-    ContributorInsightsSpecification: Optional[ContributorInsightsSpecification]
-    ProvisionedThroughput: Optional[ProvisionedThroughput]
+    IndexName: str | None
+    KeySchema: list[KeySchema] | None
+    Projection: Projection | None
+    ContributorInsightsSpecification: ContributorInsightsSpecification | None
+    ProvisionedThroughput: ProvisionedThroughput | None
 
 
 class LocalSecondaryIndex(TypedDict):
-    IndexName: Optional[str]
-    KeySchema: Optional[list[KeySchema]]
-    Projection: Optional[Projection]
+    IndexName: str | None
+    KeySchema: list[KeySchema] | None
+    Projection: Projection | None
 
 
 class PointInTimeRecoverySpecification(TypedDict):
-    PointInTimeRecoveryEnabled: Optional[bool]
+    PointInTimeRecoveryEnabled: bool | None
 
 
 class SSESpecification(TypedDict):
-    SSEEnabled: Optional[bool]
-    KMSMasterKeyId: Optional[str]
-    SSEType: Optional[str]
+    SSEEnabled: bool | None
+    KMSMasterKeyId: str | None
+    SSEType: str | None
 
 
 class StreamSpecification(TypedDict):
-    StreamViewType: Optional[str]
+    StreamViewType: str | None
 
 
 class Tag(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 class TimeToLiveSpecification(TypedDict):
-    AttributeName: Optional[str]
-    Enabled: Optional[bool]
+    AttributeName: str | None
+    Enabled: bool | None
 
 
 class KinesisStreamSpecification(TypedDict):
-    StreamArn: Optional[str]
+    StreamArn: str | None
 
 
 class S3BucketSource(TypedDict):
-    S3Bucket: Optional[str]
-    S3BucketOwner: Optional[str]
-    S3KeyPrefix: Optional[str]
+    S3Bucket: str | None
+    S3BucketOwner: str | None
+    S3KeyPrefix: str | None
 
 
 class Csv(TypedDict):
-    Delimiter: Optional[str]
-    HeaderList: Optional[list[str]]
+    Delimiter: str | None
+    HeaderList: list[str] | None
 
 
 class InputFormatOptions(TypedDict):
-    Csv: Optional[Csv]
+    Csv: Csv | None
 
 
 class ImportSourceSpecification(TypedDict):
-    InputFormat: Optional[str]
-    S3BucketSource: Optional[S3BucketSource]
-    InputCompressionType: Optional[str]
-    InputFormatOptions: Optional[InputFormatOptions]
+    InputFormat: str | None
+    S3BucketSource: S3BucketSource | None
+    InputCompressionType: str | None
+    InputFormatOptions: InputFormatOptions | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/dynamodb/resource_providers/aws_dynamodb_table_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 DynamoDBTableProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::DynamoDB::Table"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.dynamodb.resource_providers.aws_dynamodb_table import (

localstack/services/dynamodb/server.py

@@ -162,7 +162,7 @@ class DynamodbServer(Server):
         cmd = [
             "java",
             *self._get_java_vm_options(),
-            "-Xmx%s" % self.heap_size,
+            f"-Xmx{self.heap_size}",
             f"-javaagent:{dynamodblocal_package.get_installer().get_ddb_agent_jar_path()}",
             f"-Djava.library.path={self.library_path}",
             "-jar",
@@ -219,7 +219,7 @@ class DynamodbServer(Server):
                 aws_secret_access_key=DEFAULT_AWS_ACCOUNT_ID,
             ).dynamodb.list_tables()
         except Exception:
-            LOG.exception("DynamoDB health check failed")
+            LOG.error("DynamoDB health check failed", exc_info=LOG.isEnabledFor(logging.DEBUG))
         if expect_shutdown:
             assert out is None
         else:

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
@@ -24,6 +23,7 @@ from localstack.aws.api import (
     handler,
 )
 from localstack.aws.api.dynamodb import (
+    ApproximateCreationDateTimePrecision,
     BatchExecuteStatementOutput,
     BatchGetItemOutput,
     BatchGetRequestMap,
@@ -40,6 +40,8 @@ from localstack.aws.api.dynamodb import (
     DeleteRequest,
     DeleteTableOutput,
     DescribeContinuousBackupsOutput,
+    DescribeContributorInsightsInput,
+    DescribeContributorInsightsOutput,
     DescribeGlobalTableOutput,
     DescribeKinesisStreamingDestinationOutput,
     DescribeTableOutput,
@@ -84,6 +86,7 @@ from localstack.aws.api.dynamodb import (
     ScanInput,
     ScanOutput,
     StreamArn,
+    TableArn,
     TableDescription,
     TableName,
     TagKeyList,
@@ -97,6 +100,8 @@ from localstack.aws.api.dynamodb import (
     UpdateGlobalTableOutput,
     UpdateItemInput,
     UpdateItemOutput,
+    UpdateKinesisStreamingConfiguration,
+    UpdateKinesisStreamingDestinationOutput,
     UpdateTableInput,
     UpdateTableOutput,
     UpdateTimeToLiveOutput,
@@ -336,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):
@@ -555,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] = {
@@ -572,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.
 
@@ -603,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 = []
 
@@ -631,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"]:
@@ -643,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)
         )
@@ -672,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():
@@ -754,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
     #
@@ -1032,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 []]
@@ -1110,7 +1155,14 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         enable_kinesis_streaming_configuration: EnableKinesisStreamingConfiguration = None,
         **kwargs,
     ) -> KinesisStreamingDestinationOutput:
-        self.ensure_table_exists(context.account_id, context.region, table_name)
+        self.ensure_table_exists(
+            context.account_id,
+            context.region,
+            table_name,
+            error_message=f"Requested resource not found: Table: {table_name} not found",
+        )
+
+        enable_kinesis_streaming_configuration = enable_kinesis_streaming_configuration or {}
 
         if not kinesis_stream_exists(stream_arn=stream_arn):
             raise ValidationException("User does not have a permission to use kinesis stream")
@@ -1127,9 +1179,8 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 "to perform ENABLE operation."
             )
 
-        table_def["KinesisDataStreamDestinations"] = (
-            table_def.get("KinesisDataStreamDestinations") or []
-        )
+        table_def.setdefault("KinesisDataStreamDestinations", [])
+
         # remove the stream destination if already present
         table_def["KinesisDataStreamDestinations"] = [
             t for t in table_def["KinesisDataStreamDestinations"] if t["StreamArn"] != stream_arn
@@ -1140,11 +1191,15 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                 "DestinationStatus": DestinationStatus.ACTIVE,
                 "DestinationStatusDescription": "Stream is active",
                 "StreamArn": stream_arn,
+                "ApproximateCreationDateTimePrecision": ApproximateCreationDateTimePrecision.MILLISECOND,
             }
         )
         table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.ACTIVE
         return KinesisStreamingDestinationOutput(
-            DestinationStatus=DestinationStatus.ACTIVE, StreamArn=stream_arn, TableName=table_name
+            DestinationStatus=DestinationStatus.ENABLING,
+            StreamArn=stream_arn,
+            TableName=table_name,
+            EnableKinesisStreamingConfiguration=enable_kinesis_streaming_configuration,
         )
 
     def disable_kinesis_streaming_destination(
@@ -1155,8 +1210,14 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         enable_kinesis_streaming_configuration: EnableKinesisStreamingConfiguration = None,
         **kwargs,
     ) -> KinesisStreamingDestinationOutput:
-        self.ensure_table_exists(context.account_id, context.region, table_name)
-        if not kinesis_stream_exists(stream_arn):
+        self.ensure_table_exists(
+            context.account_id,
+            context.region,
+            table_name,
+            error_message=f"Requested resource not found: Table: {table_name} not found",
+        )
+
+        if not kinesis_stream_exists(stream_arn=stream_arn):
             raise ValidationException(
                 "User does not have a permission to use kinesis stream",
             )
@@ -1177,7 +1238,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
                         dest["DestinationStatusDescription"] = ("Stream is disabled",)
                         table_def["KinesisDataStreamDestinationStatus"] = DestinationStatus.DISABLED
                         return KinesisStreamingDestinationOutput(
-                            DestinationStatus=DestinationStatus.DISABLED,
+                            DestinationStatus=DestinationStatus.DISABLING,
                             StreamArn=stream_arn,
                             TableName=table_name,
                         )
@@ -1196,8 +1257,81 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         )
 
         stream_destinations = table_def.get("KinesisDataStreamDestinations") or []
+        stream_destinations = copy.deepcopy(stream_destinations)
+
+        for destination in stream_destinations:
+            destination.pop("ApproximateCreationDateTimePrecision", None)
+            destination.pop("DestinationStatusDescription", None)
+
         return DescribeKinesisStreamingDestinationOutput(
-            KinesisDataStreamDestinations=stream_destinations, TableName=table_name
+            KinesisDataStreamDestinations=stream_destinations,
+            TableName=table_name,
+        )
+
+    def update_kinesis_streaming_destination(
+        self,
+        context: RequestContext,
+        table_name: TableArn,
+        stream_arn: StreamArn,
+        update_kinesis_streaming_configuration: UpdateKinesisStreamingConfiguration | None = None,
+        **kwargs,
+    ) -> UpdateKinesisStreamingDestinationOutput:
+        self.ensure_table_exists(context.account_id, context.region, table_name)
+
+        if not update_kinesis_streaming_configuration:
+            raise ValidationException(
+                "Streaming destination cannot be updated with given parameters: "
+                "UpdateKinesisStreamingConfiguration cannot be null or contain only null values"
+            )
+
+        time_precision = update_kinesis_streaming_configuration.get(
+            "ApproximateCreationDateTimePrecision"
+        )
+        if time_precision not in (
+            ApproximateCreationDateTimePrecision.MILLISECOND,
+            ApproximateCreationDateTimePrecision.MICROSECOND,
+        ):
+            raise ValidationException(
+                f"1 validation error detected: Value '{time_precision}' at "
+                "'updateKinesisStreamingConfiguration.approximateCreationDateTimePrecision' failed to satisfy constraint: "
+                "Member must satisfy enum value set: [MILLISECOND, MICROSECOND]"
+            )
+
+        store = get_store(context.account_id, context.region)
+
+        table_def = store.table_definitions.get(table_name) or {}
+        table_def.setdefault("KinesisDataStreamDestinations", [])
+
+        table_id = table_def["TableId"]
+
+        destination = None
+        for stream in table_def["KinesisDataStreamDestinations"]:
+            if stream["StreamArn"] == stream_arn:
+                destination = stream
+
+        if destination is None:
+            raise ValidationException(
+                "Table is not in a valid state to enable Kinesis Streaming Destination: "
+                f"No streaming destination with streamArn: {stream_arn} found for table with tableName: {table_name}"
+            )
+
+        if (
+            existing_precision := destination["ApproximateCreationDateTimePrecision"]
+        ) == update_kinesis_streaming_configuration["ApproximateCreationDateTimePrecision"]:
+            raise ValidationException(
+                f"Invalid Request: Precision is already set to the desired value of {existing_precision} "
+                f"for tableId: {table_id}, kdsArn: {stream_arn}"
+            )
+
+        destination["ApproximateCreationDateTimePrecision"] = time_precision
+
+        return UpdateKinesisStreamingDestinationOutput(
+            TableName=table_name,
+            StreamArn=stream_arn,
+            DestinationStatus=DestinationStatus.UPDATING,
+            UpdateKinesisStreamingConfiguration=UpdateKinesisStreamingConfiguration(
+                ApproximateCreationDateTimePrecision=time_precision,
+            ),
         )
 
     #
@@ -1275,7 +1409,12 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         return dynamodb_table_exists(table_name, client)
 
     @staticmethod
-    def ensure_table_exists(account_id: str, region_name: str, table_name: str):
+    def ensure_table_exists(
+        account_id: str,
+        region_name: str,
+        table_name: str,
+        error_message: str = "Cannot do operations on a non-existent table",
+    ):
         """
         Raise ResourceNotFoundException if the given table does not exist.
 
@@ -1285,7 +1424,7 @@ class DynamoDBProvider(DynamodbApi, ServiceLifecycleHook):
         :raise: ResourceNotFoundException if table does not exist in DynamoDB Local
         """
         if not DynamoDBProvider.table_exists(account_id, region_name, table_name):
-            raise ResourceNotFoundException("Cannot do operations on a non-existent table")
+            raise ResourceNotFoundException(error_message)
 
     @staticmethod
     def get_global_table_region(context: RequestContext, table_name: str) -> str:
@@ -1312,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.
         """
@@ -1329,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)