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

localstack/services/events/resource_providers/aws_events_rule.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 
 import json
 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 (
@@ -16,153 +16,153 @@ from localstack.utils import common
 
 
 class EventsRuleProperties(TypedDict):
-    Arn: Optional[str]
-    Description: Optional[str]
-    EventBusName: Optional[str]
-    EventPattern: Optional[dict]
-    Id: Optional[str]
-    Name: Optional[str]
-    RoleArn: Optional[str]
-    ScheduleExpression: Optional[str]
-    State: Optional[str]
-    Targets: Optional[list[Target]]
+    Arn: str | None
+    Description: str | None
+    EventBusName: str | None
+    EventPattern: dict | None
+    Id: str | None
+    Name: str | None
+    RoleArn: str | None
+    ScheduleExpression: str | None
+    State: str | None
+    Targets: list[Target] | None
 
 
 class HttpParameters(TypedDict):
-    HeaderParameters: Optional[dict]
-    PathParameterValues: Optional[list[str]]
-    QueryStringParameters: Optional[dict]
+    HeaderParameters: dict | None
+    PathParameterValues: list[str] | None
+    QueryStringParameters: dict | None
 
 
 class DeadLetterConfig(TypedDict):
-    Arn: Optional[str]
+    Arn: str | None
 
 
 class RunCommandTarget(TypedDict):
-    Key: Optional[str]
-    Values: Optional[list[str]]
+    Key: str | None
+    Values: list[str] | None
 
 
 class RunCommandParameters(TypedDict):
-    RunCommandTargets: Optional[list[RunCommandTarget]]
+    RunCommandTargets: list[RunCommandTarget] | None
 
 
 class InputTransformer(TypedDict):
-    InputTemplate: Optional[str]
-    InputPathsMap: Optional[dict]
+    InputTemplate: str | None
+    InputPathsMap: dict | None
 
 
 class KinesisParameters(TypedDict):
-    PartitionKeyPath: Optional[str]
+    PartitionKeyPath: str | None
 
 
 class RedshiftDataParameters(TypedDict):
-    Database: Optional[str]
-    Sql: Optional[str]
-    DbUser: Optional[str]
-    SecretManagerArn: Optional[str]
-    StatementName: Optional[str]
-    WithEvent: Optional[bool]
+    Database: str | None
+    Sql: str | None
+    DbUser: str | None
+    SecretManagerArn: str | None
+    StatementName: str | None
+    WithEvent: bool | None
 
 
 class SqsParameters(TypedDict):
-    MessageGroupId: Optional[str]
+    MessageGroupId: str | None
 
 
 class PlacementConstraint(TypedDict):
-    Expression: Optional[str]
-    Type: Optional[str]
+    Expression: str | None
+    Type: str | None
 
 
 class PlacementStrategy(TypedDict):
-    Field: Optional[str]
-    Type: Optional[str]
+    Field: str | None
+    Type: str | None
 
 
 class CapacityProviderStrategyItem(TypedDict):
-    CapacityProvider: Optional[str]
-    Base: Optional[int]
-    Weight: Optional[int]
+    CapacityProvider: str | None
+    Base: int | None
+    Weight: int | None
 
 
 class Tag(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 class AwsVpcConfiguration(TypedDict):
-    Subnets: Optional[list[str]]
-    AssignPublicIp: Optional[str]
-    SecurityGroups: Optional[list[str]]
+    Subnets: list[str] | None
+    AssignPublicIp: str | None
+    SecurityGroups: list[str] | None
 
 
 class NetworkConfiguration(TypedDict):
-    AwsVpcConfiguration: Optional[AwsVpcConfiguration]
+    AwsVpcConfiguration: AwsVpcConfiguration | None
 
 
 class EcsParameters(TypedDict):
-    TaskDefinitionArn: Optional[str]
-    CapacityProviderStrategy: Optional[list[CapacityProviderStrategyItem]]
-    EnableECSManagedTags: Optional[bool]
-    EnableExecuteCommand: Optional[bool]
-    Group: Optional[str]
-    LaunchType: Optional[str]
-    NetworkConfiguration: Optional[NetworkConfiguration]
-    PlacementConstraints: Optional[list[PlacementConstraint]]
-    PlacementStrategies: Optional[list[PlacementStrategy]]
-    PlatformVersion: Optional[str]
-    PropagateTags: Optional[str]
-    ReferenceId: Optional[str]
-    TagList: Optional[list[Tag]]
-    TaskCount: Optional[int]
+    TaskDefinitionArn: str | None
+    CapacityProviderStrategy: list[CapacityProviderStrategyItem] | None
+    EnableECSManagedTags: bool | None
+    EnableExecuteCommand: bool | None
+    Group: str | None
+    LaunchType: str | None
+    NetworkConfiguration: NetworkConfiguration | None
+    PlacementConstraints: list[PlacementConstraint] | None
+    PlacementStrategies: list[PlacementStrategy] | None
+    PlatformVersion: str | None
+    PropagateTags: str | None
+    ReferenceId: str | None
+    TagList: list[Tag] | None
+    TaskCount: int | None
 
 
 class BatchRetryStrategy(TypedDict):
-    Attempts: Optional[int]
+    Attempts: int | None
 
 
 class BatchArrayProperties(TypedDict):
-    Size: Optional[int]
+    Size: int | None
 
 
 class BatchParameters(TypedDict):
-    JobDefinition: Optional[str]
-    JobName: Optional[str]
-    ArrayProperties: Optional[BatchArrayProperties]
-    RetryStrategy: Optional[BatchRetryStrategy]
+    JobDefinition: str | None
+    JobName: str | None
+    ArrayProperties: BatchArrayProperties | None
+    RetryStrategy: BatchRetryStrategy | None
 
 
 class SageMakerPipelineParameter(TypedDict):
-    Name: Optional[str]
-    Value: Optional[str]
+    Name: str | None
+    Value: str | None
 
 
 class SageMakerPipelineParameters(TypedDict):
-    PipelineParameterList: Optional[list[SageMakerPipelineParameter]]
+    PipelineParameterList: list[SageMakerPipelineParameter] | None
 
 
 class RetryPolicy(TypedDict):
-    MaximumEventAgeInSeconds: Optional[int]
-    MaximumRetryAttempts: Optional[int]
+    MaximumEventAgeInSeconds: int | None
+    MaximumRetryAttempts: int | None
 
 
 class Target(TypedDict):
-    Arn: Optional[str]
-    Id: Optional[str]
-    BatchParameters: Optional[BatchParameters]
-    DeadLetterConfig: Optional[DeadLetterConfig]
-    EcsParameters: Optional[EcsParameters]
-    HttpParameters: Optional[HttpParameters]
-    Input: Optional[str]
-    InputPath: Optional[str]
-    InputTransformer: Optional[InputTransformer]
-    KinesisParameters: Optional[KinesisParameters]
-    RedshiftDataParameters: Optional[RedshiftDataParameters]
-    RetryPolicy: Optional[RetryPolicy]
-    RoleArn: Optional[str]
-    RunCommandParameters: Optional[RunCommandParameters]
-    SageMakerPipelineParameters: Optional[SageMakerPipelineParameters]
-    SqsParameters: Optional[SqsParameters]
+    Arn: str | None
+    Id: str | None
+    BatchParameters: BatchParameters | None
+    DeadLetterConfig: DeadLetterConfig | None
+    EcsParameters: EcsParameters | None
+    HttpParameters: HttpParameters | None
+    Input: str | None
+    InputPath: str | None
+    InputTransformer: InputTransformer | None
+    KinesisParameters: KinesisParameters | None
+    RedshiftDataParameters: RedshiftDataParameters | None
+    RetryPolicy: RetryPolicy | None
+    RoleArn: str | None
+    RunCommandParameters: RunCommandParameters | None
+    SageMakerPipelineParameters: SageMakerPipelineParameters | None
+    SqsParameters: SqsParameters | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/events/resource_providers/aws_events_rule_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 EventsRuleProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::Events::Rule"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.events.resource_providers.aws_events_rule import EventsRuleProvider

localstack/services/events/rule.py

@@ -1,5 +1,5 @@
 import re
-from typing import Callable, Optional
+from collections.abc import Callable
 
 from localstack.aws.api.events import (
     Arn,
@@ -75,17 +75,17 @@ class RuleService:
     def create_rule_service(
         cls,
         name: RuleName,
-        region: Optional[str] = None,
-        account_id: Optional[str] = None,
-        schedule_expression: Optional[ScheduleExpression] = None,
-        event_pattern: Optional[EventPattern] = None,
-        state: Optional[RuleState] = None,
-        description: Optional[RuleDescription] = None,
-        role_arn: Optional[RoleArn] = None,
-        tags: Optional[TagList] = None,
-        event_bus_name: Optional[EventBusName] = None,
-        targets: Optional[TargetDict] = None,
-        managed_by: Optional[ManagedBy] = None,
+        region: str | None = None,
+        account_id: str | None = None,
+        schedule_expression: ScheduleExpression | None = None,
+        event_pattern: EventPattern | None = None,
+        state: RuleState | None = None,
+        description: RuleDescription | None = None,
+        role_arn: RoleArn | None = None,
+        tags: TagList | None = None,
+        event_bus_name: EventBusName | None = None,
+        targets: TargetDict | None = None,
+        managed_by: ManagedBy | None = None,
     ):
         cls._validate_input(event_pattern, schedule_expression, event_bus_name)
         # required to keep data and functionality separate for persistence
@@ -209,9 +209,9 @@ class RuleService:
     @classmethod
     def _validate_input(
         cls,
-        event_pattern: Optional[EventPattern],
-        schedule_expression: Optional[ScheduleExpression],
-        event_bus_name: Optional[EventBusName] = "default",
+        event_pattern: EventPattern | None,
+        schedule_expression: ScheduleExpression | None,
+        event_bus_name: EventBusName | None = "default",
     ) -> None:
         if not event_pattern and not schedule_expression:
             raise ValidationException(

localstack/services/events/target.py

@@ -4,7 +4,7 @@ import logging
 import re
 import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Dict, Set, Type
+from typing import Any
 from urllib.parse import urlencode
 
 import requests
@@ -59,7 +59,7 @@ AWS_PREDEFINED_PLACEHOLDERS_STRING_VALUES = {
 }
 AWS_PREDEFINED_PLACEHOLDERS_JSON_VALUES = {"aws.events.event", "aws.events.event.json"}
 
-PREDEFINED_PLACEHOLDERS: Set[str] = AWS_PREDEFINED_PLACEHOLDERS_STRING_VALUES.union(
+PREDEFINED_PLACEHOLDERS: set[str] = AWS_PREDEFINED_PLACEHOLDERS_STRING_VALUES.union(
     AWS_PREDEFINED_PLACEHOLDERS_JSON_VALUES
 )
 
@@ -90,11 +90,20 @@ def get_template_replacements(
     return template_replacements
 
 
-def replace_template_placeholders(
-    template: str, replacements: dict[str, Any], is_json_template: bool
-) -> TransformedEvent:
-    """Replace placeholders defined by <key> in the template with the values from the replacements dict.
-    Can handle single template string or template dict."""
+def replace_template_placeholders(template: str, replacements: dict[str, Any]) -> TransformedEvent:
+    """
+    Replaces placeholders in an EventBridge-style InputTemplate string.
+
+    :param template: The template string containing placeholders like ``<$.foo.bar>``.
+    :type template: str
+    :param replacements: A dictionary providing values to fill in.
+    :type replacements: dict
+    :returns: The transformed string with placeholders replaced by values from ``replacements``.
+    :rtype: str
+    """
+
+    ...
+    is_json_template = template.strip().startswith("{")
 
     def replace_placeholder(match):
         key = match.group(1)
@@ -110,6 +119,8 @@ def replace_template_placeholders(
             if is_json_template:
                 return json.dumps(value)
             return f"[{','.join(value)}]"
+        if isinstance(value, bool):
+            return json.dumps(value)
         if is_nested_in_string(template, match):
             return value
         if is_json_template:
@@ -222,10 +233,7 @@ class TargetSender(ABC):
         predefined_template_replacements = self._get_predefined_template_replacements(event)
         template_replacements.update(predefined_template_replacements)
 
-        is_json_template = input_template.strip().startswith(("{"))
-        populated_template = replace_template_placeholders(
-            input_template, template_replacements, is_json_template
-        )
+        populated_template = replace_template_placeholders(input_template, template_replacements)
 
         return populated_template
 
@@ -424,7 +432,7 @@ class ApiGatewayTargetSender(TargetSender):
         # if not collections.get_safe(target, "$.RoleArn"):
         #     raise ValueError("RoleArn is required for ApiGateway target")
 
-    def _get_predefined_template_replacements(self, event: Dict[str, Any]) -> Dict[str, Any]:
+    def _get_predefined_template_replacements(self, event: dict[str, Any]) -> dict[str, Any]:
         """Extracts predefined values from the event."""
         predefined_template_replacements = {}
         predefined_template_replacements["aws.events.rule-arn"] = self.rule_arn
@@ -731,7 +739,7 @@ class TargetSenderFactory:
         self.account_id = account_id
 
     @classmethod
-    def register_target_sender(cls, service_name: str, sender_class: Type[TargetSender]):
+    def register_target_sender(cls, service_name: str, sender_class: type[TargetSender]):
         cls.target_map[service_name] = sender_class
 
     def get_target_sender(self) -> TargetSender:

localstack/services/events/utils.py

@@ -1,8 +1,8 @@
 import json
 import logging
 import re
-from datetime import datetime, timezone
-from typing import Any, Dict, Optional
+from datetime import UTC, datetime
+from typing import Any
 
 from botocore.utils import ArnParser
 
@@ -57,7 +57,7 @@ class EventJSONEncoder(json.JSONEncoder):
         return super().default(obj)
 
 
-def to_json_str(obj: Any, separators: Optional[tuple[str, str]] = (",", ":")) -> str:
+def to_json_str(obj: Any, separators: tuple[str, str] | None = (",", ":")) -> str:
     return json.dumps(obj, cls=EventJSONEncoder, separators=separators)
 
 
@@ -132,11 +132,11 @@ def get_resource_type(arn: Arn) -> ResourceType:
 
 
 def get_event_time(event: PutEventsRequestEntry) -> EventTime:
-    event_time = datetime.now(timezone.utc)
+    event_time = datetime.now(UTC)
     if event_timestamp := event.get("Time"):
         try:
             # use time from event if provided
-            event_time = event_timestamp.replace(tzinfo=timezone.utc)
+            event_time = event_timestamp.replace(tzinfo=UTC)
         except ValueError:
             # use current time if event time is invalid
             LOG.debug(
@@ -154,11 +154,11 @@ def convert_to_timezone_aware_datetime(
     timestamp: Timestamp,
 ) -> Timestamp:
     if timestamp.tzinfo is None:
-        timestamp = timestamp.replace(tzinfo=timezone.utc)
+        timestamp = timestamp.replace(tzinfo=UTC)
     return timestamp
 
 
-def recursive_remove_none_values_from_dict(d: Dict[str, Any]) -> Dict[str, Any]:
+def recursive_remove_none_values_from_dict(d: dict[str, Any]) -> dict[str, Any]:
     """
     Recursively removes keys with non values from a dictionary.
     """

localstack/services/events/v1/models.py

@@ -1,11 +1,9 @@
-from typing import Dict
-
 from localstack.services.stores import AccountRegionBundle, BaseStore, LocalAttribute
 
 
 class EventsStore(BaseStore):
     # maps rule name to job_id
-    rule_scheduled_jobs: Dict[str, str] = LocalAttribute(default=dict)
+    rule_scheduled_jobs: dict[str, str] = LocalAttribute(default=dict)
 
 
 events_stores = AccountRegionBundle("events", EventsStore)

localstack/services/events/v1/provider.py

@@ -4,7 +4,7 @@ import logging
 import os
 import re
 import time
-from typing import Any, Dict, Optional
+from typing import Any
 
 from moto.events import events_backends
 from moto.events.responses import EventsHandler as MotoEventsHandler
@@ -119,7 +119,7 @@ class EventsProvider(EventsApi, ServiceLifecycleHook):
     def get_scheduled_rule_func(
         store: EventsStore,
         rule_name: RuleName,
-        event_bus_name_or_arn: Optional[EventBusNameOrArn] = None,
+        event_bus_name_or_arn: EventBusNameOrArn | None = None,
     ):
         def func(*args, **kwargs):
             account_id = store._account_id
@@ -206,21 +206,21 @@ class EventsProvider(EventsApi, ServiceLifecycleHook):
                 raise ValueError("If the value is greater than 1, the unit must be plural")
 
             if "minute" in unit:
-                return "*/%s * * * *" % value
+                return f"*/{value} * * * *"
             if "hour" in unit:
-                return "0 */%s * * *" % value
+                return f"0 */{value} * * *"
             if "day" in unit:
-                return "0 0 */%s * *" % value
-            raise ValueError("Unable to parse events schedule expression: %s" % schedule)
+                return f"0 0 */{value} * *"
+            raise ValueError(f"Unable to parse events schedule expression: {schedule}")
         return schedule
 
     @staticmethod
     def put_rule_job_scheduler(
         store: EventsStore,
-        name: Optional[RuleName],
-        state: Optional[RuleState],
-        schedule_expression: Optional[ScheduleExpression],
-        event_bus_name_or_arn: Optional[EventBusNameOrArn] = None,
+        name: RuleName | None,
+        state: RuleState | None,
+        schedule_expression: ScheduleExpression | None,
+        event_bus_name_or_arn: EventBusNameOrArn | None = None,
     ):
         if not schedule_expression:
             return
@@ -374,7 +374,7 @@ def _dump_events_to_files(events_with_added_uuid):
         for event in events_with_added_uuid:
             target = os.path.join(
                 _get_events_tmp_dir(),
-                "%s_%s" % (current_time_millis, event["uuid"]),
+                "{}_{}".format(current_time_millis, event["uuid"]),
             )
             save_file(target, json.dumps(event["event"]))
     except Exception as e:
@@ -398,14 +398,14 @@ def filter_event_based_on_event_format(
     return True
 
 
-def filter_event_with_target_input_path(target: Dict, event: Dict) -> Dict:
+def filter_event_with_target_input_path(target: dict, event: dict) -> dict:
     input_path = target.get("InputPath")
     if input_path:
         event = extract_jsonpath(event, input_path)
     return event
 
 
-def process_event_with_input_transformer(input_transformer: Dict, event: Dict) -> Dict:
+def process_event_with_input_transformer(input_transformer: dict, event: dict) -> dict:
     """
     Process the event with the input transformer of the target event,
     by replacing the message with the populated InputTemplate.
@@ -426,7 +426,7 @@ def process_event_with_input_transformer(input_transformer: Dict, event: Dict) -
     return templated_event
 
 
-def process_events(event: Dict, targets: list[Dict]):
+def process_events(event: dict, targets: list[dict]):
     for target in targets:
         arn = target["Arn"]
         changed_event = filter_event_with_target_input_path(target, event)
@@ -453,7 +453,7 @@ def process_events(event: Dict, targets: list[Dict]):
             )
 
 
-def get_event_bus_name(event_bus_name_or_arn: Optional[EventBusNameOrArn] = None) -> str:
+def get_event_bus_name(event_bus_name_or_arn: EventBusNameOrArn | None = None) -> str:
     event_bus_name_or_arn = event_bus_name_or_arn or DEFAULT_EVENT_BUS_NAME
     return event_bus_name_or_arn.split("/")[-1]
 

localstack/services/firehose/models.py

@@ -1,5 +1,3 @@
-from typing import Dict
-
 from localstack.aws.api.firehose import DeliveryStreamDescription
 from localstack.services.stores import (
     AccountRegionBundle,
@@ -12,7 +10,7 @@ from localstack.utils.tagging import TaggingService
 
 class FirehoseStore(BaseStore):
     # maps delivery stream names to DeliveryStreamDescription
-    delivery_streams: Dict[str, DeliveryStreamDescription] = LocalAttribute(default=dict)
+    delivery_streams: dict[str, DeliveryStreamDescription] = LocalAttribute(default=dict)
 
     # static tagging service instance
     TAGS = CrossRegionAttribute(default=TaggingService)