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

localstack/services/ssm/resource_providers/aws_ssm_patchbaseline_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 SSMPatchBaselineProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::SSM::PatchBaseline"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.ssm.resource_providers.aws_ssm_patchbaseline import (

localstack/services/stepfunctions/asl/antlt4utils/antlr4utils.py

@@ -1,11 +1,10 @@
 import ast
-from typing import Optional
 
 from antlr4 import ParserRuleContext
 from antlr4.tree.Tree import ParseTree, TerminalNodeImpl
 
 
-def is_production(pt: ParseTree, rule_index: Optional[int] = None) -> Optional[ParserRuleContext]:
+def is_production(pt: ParseTree, rule_index: int | None = None) -> ParserRuleContext | None:
     if isinstance(pt, ParserRuleContext):
         prc = pt.getRuleContext()  # noqa
         if rule_index is not None:
@@ -14,7 +13,7 @@ def is_production(pt: ParseTree, rule_index: Optional[int] = None) -> Optional[P
     return None
 
 
-def is_terminal(pt: ParseTree, token_type: Optional[int] = None) -> Optional[TerminalNodeImpl]:
+def is_terminal(pt: ParseTree, token_type: int | None = None) -> TerminalNodeImpl | None:
     if isinstance(pt, TerminalNodeImpl):
         if token_type is not None:
             return pt if pt.getSymbol().type == token_type else None
@@ -22,7 +21,7 @@ def is_terminal(pt: ParseTree, token_type: Optional[int] = None) -> Optional[Ter
     return None
 
 
-def from_string_literal(parser_rule_context: ParserRuleContext) -> Optional[str]:
+def from_string_literal(parser_rule_context: ParserRuleContext) -> str | None:
     string_literal = parser_rule_context.getText()
     if string_literal.startswith('"') and string_literal.endswith('"'):
         string_literal = string_literal[1:-1]

localstack/services/stepfunctions/asl/component/common/assign/assign_decl.py

@@ -15,7 +15,7 @@ class AssignDecl(EvalComponent):
         self.declaration_bindings = declaration_bindings
 
     def _eval_body(self, env: Environment) -> None:
-        declarations: dict[str, Any] = dict()
+        declarations: dict[str, Any] = {}
         for declaration_binding in self.declaration_bindings:
             declaration_binding.eval(env=env)
             binding: dict[str, Any] = env.stack.pop()

localstack/services/stepfunctions/asl/component/common/assign/assign_decl_binding.py

@@ -15,5 +15,5 @@ class AssignDeclBinding(EvalComponent):
         self.binding = binding
 
     def _eval_body(self, env: Environment) -> None:
-        env.stack.append(dict())
+        env.stack.append({})
         self.binding.eval(env=env)

localstack/services/stepfunctions/asl/component/common/assign/assign_template_value_array.py

@@ -13,7 +13,7 @@ class AssignTemplateValueArray(AssignTemplateValue):
         self.values = values
 
     def _eval_body(self, env: Environment) -> None:
-        arr = list()
+        arr = []
         for value in self.values:
             value.eval(env)
             arr.append(env.stack.pop())

localstack/services/stepfunctions/asl/component/common/assign/assign_template_value_object.py

@@ -16,6 +16,6 @@ class AssignTemplateValueObject(AssignTemplateValue):
         self.bindings = bindings
 
     def _eval_body(self, env: Environment) -> None:
-        env.stack.append(dict())
+        env.stack.append({})
         for binding in self.bindings:
             binding.eval(env)

localstack/services/stepfunctions/asl/component/common/catch/catcher_decl.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.common.assign.assign_decl import AssignDecl
 from localstack.services.stepfunctions.asl.component.common.catch.catcher_outcome import (
@@ -34,19 +34,19 @@ class CatcherDecl(EvalComponent):
 
     error_equals: Final[ErrorEqualsDecl]
     next_decl: Final[Next]
-    result_path: Final[Optional[ResultPath]]
-    assign: Final[Optional[AssignDecl]]
-    output: Final[Optional[Output]]
-    comment: Final[Optional[Comment]]
+    result_path: Final[ResultPath | None]
+    assign: Final[AssignDecl | None]
+    output: Final[Output | None]
+    comment: Final[Comment | None]
 
     def __init__(
         self,
         error_equals: ErrorEqualsDecl,
         next_decl: Next,
-        result_path: Optional[ResultPath],
-        assign: Optional[AssignDecl],
-        output: Optional[Output],
-        comment: Optional[Comment],
+        result_path: ResultPath | None,
+        assign: AssignDecl | None,
+        output: Output | None,
+        comment: Comment | None,
     ):
         self.error_equals = error_equals
         self.next_decl = next_decl

localstack/services/stepfunctions/asl/component/common/error_name/custom_error_name.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.common.error_name.error_name import ErrorName
 
@@ -10,7 +10,7 @@ class CustomErrorName(ErrorName):
     States MAY report errors with other names, which MUST NOT begin with the prefix "States.".
     """
 
-    def __init__(self, error_name: Optional[str]):
+    def __init__(self, error_name: str | None):
         if error_name is not None and error_name.startswith(ILLEGAL_CUSTOM_ERROR_PREFIX):
             raise ValueError(
                 f"Custom Error Names MUST NOT begin with the prefix 'States.', got '{error_name}'."

localstack/services/stepfunctions/asl/component/common/error_name/error_name.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 import abc
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.component import Component
 
 
 class ErrorName(Component, abc.ABC):
-    error_name: Final[Optional[str]]
+    error_name: Final[str | None]
 
-    def __init__(self, error_name: Optional[str]):
+    def __init__(self, error_name: str | None):
         self.error_name = error_name
 
-    def matches(self, error_name: Optional[str]) -> bool:
+    def matches(self, error_name: str | None) -> bool:
         return self.error_name == error_name
 
     def __eq__(self, other):

localstack/services/stepfunctions/asl/component/common/error_name/failure_event.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import (
     EvaluationFailedEventDetails,
@@ -16,16 +16,16 @@ from localstack.services.stepfunctions.asl.eval.event.event_detail import EventD
 class FailureEvent:
     state_name: Final[str]
     source_event_id: Final[int]
-    error_name: Final[Optional[ErrorName]]
+    error_name: Final[ErrorName | None]
     event_type: Final[HistoryEventType]
-    event_details: Final[Optional[EventDetails]]
+    event_details: Final[EventDetails | None]
 
     def __init__(
         self,
         env: Environment,
-        error_name: Optional[ErrorName],
+        error_name: ErrorName | None,
         event_type: HistoryEventType,
-        event_details: Optional[EventDetails] = None,
+        event_details: EventDetails | None = None,
     ):
         self.state_name = env.next_state_name
         self.source_event_id = env.event_history_context.source_event_id
@@ -40,7 +40,7 @@ class FailureEventException(Exception):
     def __init__(self, failure_event: FailureEvent):
         self.failure_event = failure_event
 
-    def extract_error_cause_pair(self) -> Optional[tuple[Optional[str], Optional[str]]]:
+    def extract_error_cause_pair(self) -> tuple[str | None, str | None] | None:
         if self.failure_event.event_details is None:
             return None
 
@@ -54,7 +54,7 @@ class FailureEventException(Exception):
             cause = failure_event_spec["cause"]
         return error, cause
 
-    def get_evaluation_failed_event_details(self) -> Optional[EvaluationFailedEventDetails]:
+    def get_evaluation_failed_event_details(self) -> EvaluationFailedEventDetails | None:
         original_failed_event_details = self.failure_event.event_details[
             "evaluationFailedEventDetails"
         ]
@@ -80,7 +80,7 @@ class FailureEventException(Exception):
 
         return evaluation_failed_event_details
 
-    def get_execution_failed_event_details(self) -> Optional[ExecutionFailedEventDetails]:
+    def get_execution_failed_event_details(self) -> ExecutionFailedEventDetails | None:
         maybe_error_cause_pair = self.extract_error_cause_pair()
         if maybe_error_cause_pair is None:
             return None

localstack/services/stepfunctions/asl/component/common/error_name/states_error_name_type.py

@@ -40,7 +40,7 @@ def _error_name(error_name: StatesErrorNameType) -> str:
 
 
 def _reverse_error_name_lookup() -> dict[str, StatesErrorNameType]:
-    lookup: dict[str, StatesErrorNameType] = dict()
+    lookup: dict[str, StatesErrorNameType] = {}
     for error_name in StatesErrorNameType:
         error_text: str = _error_name(error_name)
         lookup[error_text] = error_name

localstack/services/stepfunctions/asl/component/common/jsonata/jsonata_template_binding.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.common.jsonata.jsonata_template_value import (
     JSONataTemplateValue,
@@ -17,7 +17,7 @@ class JSONataTemplateBinding(EvalComponent):
         self.identifier = identifier
         self.value = value
 
-    def _field_name(self) -> Optional[str]:
+    def _field_name(self) -> str | None:
         return self.identifier
 
     def _eval_body(self, env: Environment) -> None:

localstack/services/stepfunctions/asl/component/common/jsonata/jsonata_template_value_array.py

@@ -13,7 +13,7 @@ class JSONataTemplateValueArray(JSONataTemplateValue):
         self.values = values
 
     def _eval_body(self, env: Environment) -> None:
-        arr = list()
+        arr = []
         for value in self.values:
             value.eval(env)
             arr.append(env.stack.pop())

localstack/services/stepfunctions/asl/component/common/jsonata/jsonata_template_value_object.py

@@ -16,6 +16,6 @@ class JSONataTemplateValueObject(JSONataTemplateValue):
         self.bindings = bindings
 
     def _eval_body(self, env: Environment) -> None:
-        env.stack.append(dict())
+        env.stack.append({})
         for binding in self.bindings:
             binding.eval(env)

localstack/services/stepfunctions/asl/component/common/path/input_path.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import HistoryEventType, TaskFailedEventDetails
 from localstack.services.stepfunctions.asl.component.common.error_name.failure_event import (
@@ -22,14 +22,14 @@ from localstack.services.stepfunctions.asl.utils.json_path import NoSuchJsonPath
 
 
 class InputPath(EvalComponent):
-    string_sampler: Final[Optional[StringSampler]]
+    string_sampler: Final[StringSampler | None]
 
-    def __init__(self, string_sampler: Optional[StringSampler]):
+    def __init__(self, string_sampler: StringSampler | None):
         self.string_sampler = string_sampler
 
     def _eval_body(self, env: Environment) -> None:
         if self.string_sampler is None:
-            env.stack.append(dict())
+            env.stack.append({})
             return
         if isinstance(self.string_sampler, StringJsonPath):
             # JsonPaths are sampled from a given state, hence pass the state's input.

localstack/services/stepfunctions/asl/component/common/path/output_path.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import HistoryEventType, TaskFailedEventDetails
 from localstack.services.stepfunctions.asl.component.common.error_name.failure_event import (
@@ -21,14 +21,14 @@ from localstack.services.stepfunctions.asl.utils.json_path import NoSuchJsonPath
 
 
 class OutputPath(EvalComponent):
-    string_sampler: Final[Optional[StringSampler]]
+    string_sampler: Final[StringSampler | None]
 
-    def __init__(self, string_sampler: Optional[StringSampler]):
+    def __init__(self, string_sampler: StringSampler | None):
         self.string_sampler = string_sampler
 
     def _eval_body(self, env: Environment) -> None:
         if self.string_sampler is None:
-            env.states.reset(input_value=dict())
+            env.states.reset(input_value={})
             return
         try:
             self.string_sampler.eval(env=env)

localstack/services/stepfunctions/asl/component/common/path/result_path.py

@@ -1,5 +1,5 @@
 import copy
-from typing import Final, Optional
+from typing import Final
 
 from jsonpath_ng import parse
 
@@ -10,9 +10,9 @@ from localstack.services.stepfunctions.asl.eval.environment import Environment
 class ResultPath(EvalComponent):
     DEFAULT_PATH: Final[str] = "$"
 
-    result_path_src: Final[Optional[str]]
+    result_path_src: Final[str | None]
 
-    def __init__(self, result_path_src: Optional[str]):
+    def __init__(self, result_path_src: str | None):
         self.result_path_src = result_path_src
 
     def _eval_body(self, env: Environment) -> None:

localstack/services/stepfunctions/asl/component/common/payload/payloadvalue/payloadarr/payload_arr.py

@@ -11,7 +11,7 @@ class PayloadArr(PayloadValue):
         self.payload_values: Final[list[PayloadValue]] = payload_values
 
     def _eval_body(self, env: Environment) -> None:
-        arr = list()
+        arr = []
         for payload_value in self.payload_values:
             payload_value.eval(env)
             arr.append(env.stack.pop())

localstack/services/stepfunctions/asl/component/common/payload/payloadvalue/payloadbinding/payload_binding.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.component.common.payload.payloadvalue.payload_value import (
     PayloadValue,
@@ -16,7 +16,7 @@ class PayloadBinding(PayloadValue, abc.ABC):
     def __init__(self, field: str):
         self.field = field
 
-    def _field_name(self) -> Optional[str]:
+    def _field_name(self) -> str | None:
         return self.field
 
     @abc.abstractmethod
@@ -36,7 +36,7 @@ class PayloadBindingStringExpressionSimple(PayloadBinding):
         super().__init__(field=field)
         self.string_expression_simple = string_expression_simple
 
-    def _field_name(self) -> Optional[str]:
+    def _field_name(self) -> str | None:
         return f"{self.field}.$"
 
     def _eval_val(self, env: Environment) -> Any:

localstack/services/stepfunctions/asl/component/common/payload/payloadvalue/payloadtmpl/payload_tmpl.py

@@ -14,6 +14,6 @@ class PayloadTmpl(PayloadValue):
         self.payload_bindings: Final[list[PayloadBinding]] = payload_bindings
 
     def _eval_body(self, env: Environment) -> None:
-        env.stack.append(dict())
+        env.stack.append({})
         for payload_binding in self.payload_bindings:
             payload_binding.eval(env)

localstack/services/stepfunctions/asl/component/common/retry/retrier_decl.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 import time
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.common.comment import Comment
 from localstack.services.stepfunctions.asl.component.common.error_name.error_equals_decl import (
@@ -38,17 +38,17 @@ class RetrierDecl(EvalComponent):
     backoff_rate: Final[BackoffRateDecl]
     max_delay_seconds: Final[MaxDelaySecondsDecl]
     jitter_strategy: Final[JitterStrategyDecl]
-    comment: Final[Optional[Comment]]
+    comment: Final[Comment | None]
 
     def __init__(
         self,
         error_equals: ErrorEqualsDecl,
-        interval_seconds: Optional[IntervalSecondsDecl] = None,
-        max_attempts: Optional[MaxAttemptsDecl] = None,
-        backoff_rate: Optional[BackoffRateDecl] = None,
-        max_delay_seconds: Optional[MaxDelaySecondsDecl] = None,
-        jitter_strategy: Optional[JitterStrategyDecl] = None,
-        comment: Optional[Comment] = None,
+        interval_seconds: IntervalSecondsDecl | None = None,
+        max_attempts: MaxAttemptsDecl | None = None,
+        backoff_rate: BackoffRateDecl | None = None,
+        max_delay_seconds: MaxDelaySecondsDecl | None = None,
+        jitter_strategy: JitterStrategyDecl | None = None,
+        comment: Comment | None = None,
     ):
         self.error_equals = error_equals
         self.interval_seconds = interval_seconds or IntervalSecondsDecl()

localstack/services/stepfunctions/asl/component/common/string/string_expression.py

@@ -1,6 +1,6 @@
 import abc
 import copy
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.aws.api.stepfunctions import HistoryEventType, TaskFailedEventDetails
 from localstack.services.events.utils import to_json_str
@@ -46,7 +46,7 @@ class StringExpression(EvalComponent, abc.ABC):
     def __init__(self, literal_value: str):
         self.literal_value = literal_value
 
-    def _field_name(self) -> Optional[str]:
+    def _field_name(self) -> str | None:
         return None
 
 
@@ -129,7 +129,7 @@ class StringVariableSample(StringSampler):
         expression_variable_references: set[VariableReference] = (
             extract_jsonata_variable_references(self.expression)
         )
-        variable_declarations_list = list()
+        variable_declarations_list = []
         if self.query_language_mode == QueryLanguageMode.JSONata:
             # Sample $states values into expression.
             states_variable_declarations: VariableDeclarations = (

localstack/services/stepfunctions/asl/component/common/timeouts/timeout.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import (
     ExecutionFailedEventDetails,
@@ -44,13 +44,13 @@ class Timeout(EvalComponent, abc.ABC):
 class TimeoutSeconds(Timeout):
     DEFAULT_TIMEOUT_SECONDS: Final[int] = 99999999
 
-    def __init__(self, timeout_seconds: int, is_default: Optional[bool] = None):
+    def __init__(self, timeout_seconds: int, is_default: bool | None = None):
         if not isinstance(timeout_seconds, int) and timeout_seconds <= 0:
             raise ValueError(
                 f"Expected non-negative integer for TimeoutSeconds, got '{timeout_seconds}' instead."
             )
         self.timeout_seconds: Final[int] = timeout_seconds
-        self.is_default: Optional[bool] = is_default
+        self.is_default: bool | None = is_default
 
     def is_default_value(self) -> bool:
         if self.is_default is not None:

localstack/services/stepfunctions/asl/component/eval_component.py

@@ -1,6 +1,5 @@
 import abc
 import logging
-from typing import Optional
 
 from localstack.services.stepfunctions.asl.component.common.error_name.failure_event import (
     FailureEventException,
@@ -14,7 +13,7 @@ LOG = logging.getLogger(__name__)
 
 
 class EvalComponent(Component, abc.ABC):
-    __heap_key: Optional[str] = None
+    __heap_key: str | None = None
 
     @property
     def heap_key(self) -> str:
@@ -82,5 +81,5 @@ class EvalComponent(Component, abc.ABC):
     def _eval_body(self, env: Environment) -> None:
         raise NotImplementedError()
 
-    def _field_name(self) -> Optional[str]:
+    def _field_name(self) -> str | None:
         return self.__class__.__name__

localstack/services/stepfunctions/asl/component/intrinsic/argument/argument.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.component.common.string.string_expression import (
     StringVariableSample,
@@ -32,9 +32,9 @@ class Argument(EvalComponent, abc.ABC):
 
 
 class ArgumentLiteral(Argument):
-    definition_value: Final[Optional[Any]]
+    definition_value: Final[Any | None]
 
-    def __init__(self, definition_value: Optional[Any]):
+    def __init__(self, definition_value: Any | None):
         self.definition_value = definition_value
 
     def _eval_argument(self, env: Environment) -> Any:
@@ -97,7 +97,7 @@ class ArgumentList(Argument):
         self.size = len(arguments)
 
     def _eval_argument(self, env: Environment) -> Any:
-        values = list()
+        values = []
         for argument in self.arguments:
             argument.eval(env=env)
             argument_value = env.stack.pop()

localstack/services/stepfunctions/asl/component/intrinsic/function/statesfunction/array/array_partition.py

@@ -60,7 +60,7 @@ class ArrayPartition(StatesFunction):
 
     @staticmethod
     def _to_chunks(array: list, chunk_size: int):
-        chunks = list()
+        chunks = []
         for i in range(0, len(array), chunk_size):
             chunks.append(array[i : i + chunk_size])
         return chunks

localstack/services/stepfunctions/asl/component/intrinsic/function/statesfunction/generic/string_format.py

@@ -95,7 +95,7 @@ class StringFormat(StatesFunction):
             value_parts: list[str] = list(map(StringFormat._to_str_repr, value))
             return f"[{', '.join(value_parts)}]"
         elif isinstance(value, dict):
-            dict_items = list()
+            dict_items = []
             for d_key, d_value in value.items():
                 d_value_lit = StringFormat._to_str_repr(d_value)
                 dict_items.append(f"{d_key}={d_value_lit}")

localstack/services/stepfunctions/asl/component/intrinsic/function/statesfunction/states_function_array.py

@@ -24,7 +24,7 @@ class StatesFunctionArray(StatesFunction):
 
     def _eval_body(self, env: Environment) -> None:
         self.argument_list.eval(env=env)
-        values: list[Any] = list()
+        values: list[Any] = []
         for _ in range(self.argument_list.size):
             values.append(env.stack.pop())
         values.reverse()

localstack/services/stepfunctions/asl/component/intrinsic/function/statesfunction/states_function_format.py

@@ -41,7 +41,7 @@ class StatesFunctionFormat(StatesFunction):
         # TODO: investigate behaviour for incorrect number of arguments in string format.
         self.argument_list.eval(env=env)
 
-        values: list[Any] = list()
+        values: list[Any] = []
         for _ in range(self.argument_list.size):
             values.append(env.stack.pop())
         string_format: str = values.pop()

localstack/services/stepfunctions/asl/component/intrinsic/jsonata.py

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.jsonata.jsonata import (
     VariableDeclarations,
@@ -75,9 +75,9 @@ _DECLARATION_BY_VARIABLE_REFERENCE: Final[dict[VariableReference, str]] = {
 def get_intrinsic_functions_declarations(
     variable_references: set[VariableReference],
 ) -> VariableDeclarations:
-    declarations: list[str] = list()
+    declarations: list[str] = []
     for variable_reference in variable_references:
-        declaration: Optional[VariableDeclarations] = _DECLARATION_BY_VARIABLE_REFERENCE.get(
+        declaration: VariableDeclarations | None = _DECLARATION_BY_VARIABLE_REFERENCE.get(
             variable_reference
         )
         if declaration:

localstack/services/stepfunctions/asl/component/intrinsic/member.py

@@ -13,4 +13,4 @@ class IdentifiedMember(Member):
 
 class DollarMember(IdentifiedMember):
     def __init__(self):
-        super(DollarMember, self).__init__(identifier="$")
+        super().__init__(identifier="$")

localstack/services/stepfunctions/asl/component/program/program.py

@@ -1,6 +1,6 @@
 import logging
 import threading
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import (
     ExecutionAbortedEventDetails,
@@ -47,18 +47,18 @@ class Program(EvalComponent):
     query_language: Final[QueryLanguage]
     start_at: Final[StartAt]
     states: Final[States]
-    timeout_seconds: Final[Optional[TimeoutSeconds]]
-    comment: Final[Optional[Comment]]
-    version: Final[Optional[Version]]
+    timeout_seconds: Final[TimeoutSeconds | None]
+    comment: Final[Comment | None]
+    version: Final[Version | None]
 
     def __init__(
         self,
         query_language: QueryLanguage,
         start_at: StartAt,
         states: States,
-        timeout_seconds: Optional[TimeoutSeconds],
-        comment: Optional[Comment] = None,
-        version: Optional[Version] = None,
+        timeout_seconds: TimeoutSeconds | None,
+        comment: Comment | None = None,
+        version: Version | None = None,
     ):
         self.query_language = query_language
         self.start_at = start_at
@@ -68,7 +68,7 @@ class Program(EvalComponent):
         self.version = version
 
     def _get_state(self, state_name: str) -> CommonStateField:
-        state: Optional[CommonStateField] = self.states.states.get(state_name, None)
+        state: CommonStateField | None = self.states.states.get(state_name, None)
         if state is None:
             raise ValueError(f"No such state {state}.")
         return state
@@ -111,7 +111,7 @@ class Program(EvalComponent):
         program_state: ProgramState = env.program_state()
         if isinstance(program_state, ProgramError):
             exec_failed_event_details = select_from_typed_dict(
-                typed_dict=ExecutionFailedEventDetails, obj=program_state.error or dict()
+                typed_dict=ExecutionFailedEventDetails, obj=program_state.error or {}
             )
             env.event_manager.add_event(
                 context=env.event_history_context,

localstack/services/stepfunctions/asl/component/program/states.py

@@ -4,4 +4,4 @@ from localstack.services.stepfunctions.asl.component.state.state import CommonSt
 
 class States(Component):
     def __init__(self):
-        self.states: dict[str, CommonStateField] = dict()
+        self.states: dict[str, CommonStateField] = {}