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

localstack/services/dynamodb/packages.py

@@ -1,5 +1,4 @@
 import os
-from typing import List
 
 from localstack import config
 from localstack.constants import ARTIFACTS_REPO, MAVEN_REPO_URL
@@ -18,7 +17,8 @@ from localstack.utils.run import run
 DDB_AGENT_JAR_URL = f"{ARTIFACTS_REPO}/raw/e4e8c8e294b1fcda90c678ff6af5d5ebe1f091eb/dynamodb-local-patch/target/ddb-local-loader-0.2.jar"
 JAVASSIST_JAR_URL = f"{MAVEN_REPO_URL}/org/javassist/javassist/3.30.2-GA/javassist-3.30.2-GA.jar"
 
-DDBLOCAL_URL = "https://d1ni2b6xgvw0s0.cloudfront.net/v3.x/dynamodb_local_latest.zip"
+# URL points to 2.x here - however the latest 3.x builds are available under this URL
+DDBLOCAL_URL = "https://d1ni2b6xgvw0s0.cloudfront.net/v2.x/dynamodb_local_latest.zip"
 
 
 class DynamoDBLocalPackage(Package):
@@ -28,7 +28,7 @@ class DynamoDBLocalPackage(Package):
     def _get_installer(self, _) -> PackageInstaller:
         return DynamoDBLocalPackageInstaller()
 
-    def get_versions(self) -> List[str]:
+    def get_versions(self) -> list[str]:
         return ["2"]
 
 

localstack/services/dynamodb/provider.py

@@ -12,7 +12,6 @@ from concurrent.futures import ThreadPoolExecutor
 from contextlib import contextmanager
 from datetime import datetime
 from operator import itemgetter
-from typing import Dict, List, Optional
 
 import requests
 import werkzeug
@@ -27,6 +26,7 @@ from localstack.aws.api import (
     handler,
 )
 from localstack.aws.api.dynamodb import (
+    ApproximateCreationDateTimePrecision,
     AttributeMap,
     BatchExecuteStatementOutput,
     BatchGetItemOutput,
@@ -47,6 +47,8 @@ from localstack.aws.api.dynamodb import (
     DeleteRequest,
     DeleteTableOutput,
     DescribeContinuousBackupsOutput,
+    DescribeContributorInsightsInput,
+    DescribeContributorInsightsOutput,
     DescribeGlobalTableOutput,
     DescribeKinesisStreamingDestinationOutput,
     DescribeTableOutput,
@@ -92,6 +94,7 @@ from localstack.aws.api.dynamodb import (
     ScanInput,
     ScanOutput,
     StreamArn,
+    TableArn,
     TableDescription,
     TableName,
     TagKeyList,
@@ -108,6 +111,8 @@ from localstack.aws.api.dynamodb import (
     UpdateGlobalTableOutput,
     UpdateItemInput,
     UpdateItemOutput,
+    UpdateKinesisStreamingConfiguration,
+    UpdateKinesisStreamingDestinationOutput,
     UpdateTableInput,
     UpdateTableOutput,
     UpdateTimeToLiveOutput,
@@ -488,7 +493,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):
@@ -743,6 +748,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] = {
@@ -760,6 +768,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.
 
@@ -792,7 +807,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 = []
 
@@ -820,6 +835,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"]:
@@ -832,6 +850,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)
         )
@@ -861,7 +890,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():
@@ -952,6 +981,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
     #
@@ -1508,7 +1553,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 []]
@@ -1586,7 +1631,15 @@ 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",
+        )
+
+        # TODO: Use the time precision in config if set
+        enable_kinesis_streaming_configuration = enable_kinesis_streaming_configuration or {}
 
         stream = self._event_forwarder.is_kinesis_stream_exists(stream_arn=stream_arn)
         if not stream:
@@ -1604,9 +1657,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
@@ -1617,11 +1669,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(
@@ -1632,7 +1688,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",
+        )
+
+        # TODO: Must raise if invoked before KinesisStreamingDestination is ACTIVE
 
         stream = self._event_forwarder.is_kinesis_stream_exists(stream_arn=stream_arn)
         if not stream:
@@ -1656,7 +1719,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,
                         )
@@ -1675,8 +1738,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,
+            ),
         )
 
     #
@@ -1754,7 +1890,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.
 
@@ -1764,7 +1905,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:
@@ -1791,7 +1932,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.
         """
@@ -1808,7 +1949,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")
@@ -2182,7 +2323,7 @@ def get_updated_records(
     account_id: str,
     region_name: str,
     table_name: str,
-    existing_items: List,
+    existing_items: list,
     server_url: str,
     table_stream_type: TableStreamType,
 ) -> RecordsMap:

localstack/services/dynamodb/resource_providers/aws_dynamodb_globaltable.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,125 +14,125 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class DynamoDBGlobalTableProperties(TypedDict):
-    AttributeDefinitions: Optional[list[AttributeDefinition]]
-    KeySchema: Optional[list[KeySchema]]
-    Replicas: Optional[list[ReplicaSpecification]]
-    Arn: Optional[str]
-    BillingMode: Optional[str]
-    GlobalSecondaryIndexes: Optional[list[GlobalSecondaryIndex]]
-    LocalSecondaryIndexes: Optional[list[LocalSecondaryIndex]]
-    SSESpecification: Optional[SSESpecification]
-    StreamArn: Optional[str]
-    StreamSpecification: Optional[StreamSpecification]
-    TableId: Optional[str]
-    TableName: Optional[str]
-    TimeToLiveSpecification: Optional[TimeToLiveSpecification]
-    WriteProvisionedThroughputSettings: Optional[WriteProvisionedThroughputSettings]
+    AttributeDefinitions: list[AttributeDefinition] | None
+    KeySchema: list[KeySchema] | None
+    Replicas: list[ReplicaSpecification] | None
+    Arn: str | None
+    BillingMode: str | None
+    GlobalSecondaryIndexes: list[GlobalSecondaryIndex] | None
+    LocalSecondaryIndexes: list[LocalSecondaryIndex] | None
+    SSESpecification: SSESpecification | None
+    StreamArn: str | None
+    StreamSpecification: StreamSpecification | None
+    TableId: str | None
+    TableName: str | None
+    TimeToLiveSpecification: TimeToLiveSpecification | None
+    WriteProvisionedThroughputSettings: WriteProvisionedThroughputSettings | 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 TargetTrackingScalingPolicyConfiguration(TypedDict):
-    TargetValue: Optional[float]
-    DisableScaleIn: Optional[bool]
-    ScaleInCooldown: Optional[int]
-    ScaleOutCooldown: Optional[int]
+    TargetValue: float | None
+    DisableScaleIn: bool | None
+    ScaleInCooldown: int | None
+    ScaleOutCooldown: int | None
 
 
 class CapacityAutoScalingSettings(TypedDict):
-    MaxCapacity: Optional[int]
-    MinCapacity: Optional[int]
-    TargetTrackingScalingPolicyConfiguration: Optional[TargetTrackingScalingPolicyConfiguration]
-    SeedCapacity: Optional[int]
+    MaxCapacity: int | None
+    MinCapacity: int | None
+    TargetTrackingScalingPolicyConfiguration: TargetTrackingScalingPolicyConfiguration | None
+    SeedCapacity: int | None
 
 
 class WriteProvisionedThroughputSettings(TypedDict):
-    WriteCapacityAutoScalingSettings: Optional[CapacityAutoScalingSettings]
+    WriteCapacityAutoScalingSettings: CapacityAutoScalingSettings | None
 
 
 class GlobalSecondaryIndex(TypedDict):
-    IndexName: Optional[str]
-    KeySchema: Optional[list[KeySchema]]
-    Projection: Optional[Projection]
-    WriteProvisionedThroughputSettings: Optional[WriteProvisionedThroughputSettings]
+    IndexName: str | None
+    KeySchema: list[KeySchema] | None
+    Projection: Projection | None
+    WriteProvisionedThroughputSettings: WriteProvisionedThroughputSettings | 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 ContributorInsightsSpecification(TypedDict):
-    Enabled: Optional[bool]
+    Enabled: bool | None
 
 
 class ReadProvisionedThroughputSettings(TypedDict):
-    ReadCapacityAutoScalingSettings: Optional[CapacityAutoScalingSettings]
-    ReadCapacityUnits: Optional[int]
+    ReadCapacityAutoScalingSettings: CapacityAutoScalingSettings | None
+    ReadCapacityUnits: int | None
 
 
 class ReplicaGlobalSecondaryIndexSpecification(TypedDict):
-    IndexName: Optional[str]
-    ContributorInsightsSpecification: Optional[ContributorInsightsSpecification]
-    ReadProvisionedThroughputSettings: Optional[ReadProvisionedThroughputSettings]
+    IndexName: str | None
+    ContributorInsightsSpecification: ContributorInsightsSpecification | None
+    ReadProvisionedThroughputSettings: ReadProvisionedThroughputSettings | None
 
 
 class PointInTimeRecoverySpecification(TypedDict):
-    PointInTimeRecoveryEnabled: Optional[bool]
+    PointInTimeRecoveryEnabled: bool | None
 
 
 class ReplicaSSESpecification(TypedDict):
-    KMSMasterKeyId: Optional[str]
+    KMSMasterKeyId: str | None
 
 
 class Tag(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 class KinesisStreamSpecification(TypedDict):
-    StreamArn: Optional[str]
+    StreamArn: str | None
 
 
 class ReplicaSpecification(TypedDict):
-    Region: Optional[str]
-    ContributorInsightsSpecification: Optional[ContributorInsightsSpecification]
-    DeletionProtectionEnabled: Optional[bool]
-    GlobalSecondaryIndexes: Optional[list[ReplicaGlobalSecondaryIndexSpecification]]
-    KinesisStreamSpecification: Optional[KinesisStreamSpecification]
-    PointInTimeRecoverySpecification: Optional[PointInTimeRecoverySpecification]
-    ReadProvisionedThroughputSettings: Optional[ReadProvisionedThroughputSettings]
-    SSESpecification: Optional[ReplicaSSESpecification]
-    TableClass: Optional[str]
-    Tags: Optional[list[Tag]]
+    Region: str | None
+    ContributorInsightsSpecification: ContributorInsightsSpecification | None
+    DeletionProtectionEnabled: bool | None
+    GlobalSecondaryIndexes: list[ReplicaGlobalSecondaryIndexSpecification] | None
+    KinesisStreamSpecification: KinesisStreamSpecification | None
+    PointInTimeRecoverySpecification: PointInTimeRecoverySpecification | None
+    ReadProvisionedThroughputSettings: ReadProvisionedThroughputSettings | None
+    SSESpecification: ReplicaSSESpecification | None
+    TableClass: str | None
+    Tags: list[Tag] | None
 
 
 class SSESpecification(TypedDict):
-    SSEEnabled: Optional[bool]
-    SSEType: Optional[str]
+    SSEEnabled: bool | None
+    SSEType: str | None
 
 
 class StreamSpecification(TypedDict):
-    StreamViewType: Optional[str]
+    StreamViewType: str | None
 
 
 class TimeToLiveSpecification(TypedDict):
-    Enabled: Optional[bool]
-    AttributeName: Optional[str]
+    Enabled: bool | None
+    AttributeName: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/dynamodb/resource_providers/aws_dynamodb_globaltable_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 DynamoDBGlobalTableProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::DynamoDB::GlobalTable"
 
     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_globaltable import (