localstack-core 4.7.1.dev23__py3-none-any.whl → 4.7.1.dev24__py3-none-any.whl

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/service/state_task_service_sqs.py

@@ -1,4 +1,4 @@
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from botocore.exceptions import ClientError
 
@@ -45,7 +45,7 @@ class StateTaskServiceSqs(StateTaskServiceCallback):
     def __init__(self):
         super().__init__(supported_integration_patterns=_SUPPORTED_INTEGRATION_PATTERNS)
 
-    def _get_supported_parameters(self) -> Optional[set[str]]:
+    def _get_supported_parameters(self) -> set[str] | None:
         return _SUPPORTED_API_PARAM_BINDINGS.get(self.resource.api_action.lower())
 
     def _from_error(self, env: Environment, ex: Exception) -> FailureEvent:
@@ -70,8 +70,8 @@ class StateTaskServiceSqs(StateTaskServiceCallback):
     def _normalise_response(
         self,
         response: Any,
-        boto_service_name: Optional[str] = None,
-        service_action_name: Optional[str] = None,
+        boto_service_name: str | None = None,
+        service_action_name: str | None = None,
     ) -> None:
         super()._normalise_response(
             response=response,

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/state_task.py

@@ -31,8 +31,8 @@ from localstack.services.stepfunctions.asl.eval.event.event_detail import EventD
 
 class StateTask(ExecutionState, abc.ABC):
     resource: Resource
-    parargs: Optional[Parargs]
-    credentials: Optional[Credentials]
+    parargs: Parargs | None
+    credentials: Credentials | None
 
     def __init__(self):
         super(StateTask, self).__init__(

localstack/services/stepfunctions/asl/component/state/state_execution/state_task/state_task_lambda.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import Union
+from typing import Any
 
 from botocore.exceptions import ClientError
 
@@ -94,7 +94,7 @@ class StateTaskLambda(StateTask):
             ),
         )
 
-    def _verify_size_quota(self, env: Environment, value: Union[str, json]) -> None:
+    def _verify_size_quota(self, env: Environment, value: str | Any) -> None:
         is_within: bool = is_within_size_quota(value=value)
         if is_within:
             return

localstack/services/stepfunctions/asl/component/state/state_fail/state_fail.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from localstack.aws.api.stepfunctions import HistoryEventType, TaskFailedEventDetails
 from localstack.services.stepfunctions.asl.component.common.error_name.custom_error_name import (
     CustomErrorName,
@@ -22,8 +20,8 @@ class StateFail(CommonStateField):
             state_entered_event_type=HistoryEventType.FailStateEntered,
             state_exited_event_type=None,
         )
-        self.cause: Optional[CauseDecl] = None
-        self.error: Optional[ErrorDecl] = None
+        self.cause: CauseDecl | None = None
+        self.error: ErrorDecl | None = None
 
     def from_state_props(self, state_props: StateProps) -> None:
         super(StateFail, self).from_state_props(state_props)

localstack/services/stepfunctions/asl/component/state/state_pass/state_pass.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from localstack.aws.api.stepfunctions import (
     HistoryEventType,
 )
@@ -21,17 +19,17 @@ class StatePass(CommonStateField):
         # Result (Optional)
         # Refers to the output of a virtual state_task that is passed on to the next state. If you include the ResultPath
         # field in your state machine definition, Result is placed as specified by ResultPath and passed on to the
-        self.result: Optional[Result] = None
+        self.result: Result | None = None
 
         # ResultPath (Optional)
         # Specifies where to place the output (relative to the input) of the virtual state_task specified in Result. The input
         # is further filtered as specified by the OutputPath field (if present) before being used as the state's output.
-        self.result_path: Optional[ResultPath] = None
+        self.result_path: ResultPath | None = None
 
         # Parameters (Optional)
         # Creates a collection of key-value pairs that will be passed as input. You can specify Parameters as a static
         # value or select from the input using a path.
-        self.parameters: Optional[Parameters] = None
+        self.parameters: Parameters | None = None
 
     def from_state_props(self, state_props: StateProps) -> None:
         super(StatePass, self).from_state_props(state_props)

localstack/services/stepfunctions/asl/component/state/state_wait/wait_function/timestamp.py

@@ -1,6 +1,6 @@
 import datetime
 import re
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import ExecutionFailedEventDetails, HistoryEventType
 from localstack.services.stepfunctions.asl.component.common.error_name.failure_event import (
@@ -47,7 +47,7 @@ class Timestamp(WaitFunction):
         return re.match(TIMESTAMP_PATTERN, timestamp) is not None
 
     @staticmethod
-    def _from_timestamp_string(timestamp: str) -> Optional[datetime]:
+    def _from_timestamp_string(timestamp: str) -> datetime.datetime | None:
         if not Timestamp._is_valid_timestamp_pattern(timestamp):
             return None
         try:

localstack/services/stepfunctions/asl/eval/callback/callback.py

@@ -1,7 +1,7 @@
 import abc
 from collections import OrderedDict
 from threading import Event, Lock
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import ActivityDoesNotExist, Arn
 from localstack.services.stepfunctions.backend.activity import Activity, ActivityTask
@@ -26,10 +26,10 @@ class CallbackOutcomeSuccess(CallbackOutcome):
 
 
 class CallbackOutcomeFailure(CallbackOutcome):
-    error: Final[Optional[str]]
-    cause: Final[Optional[str]]
+    error: Final[str | None]
+    cause: Final[str | None]
 
-    def __init__(self, callback_id: CallbackId, error: Optional[str], cause: Optional[str]):
+    def __init__(self, callback_id: CallbackId, error: str | None, cause: str | None):
         super().__init__(callback_id=callback_id)
         self.error = error
         self.cause = cause
@@ -85,20 +85,20 @@ class HeartbeatTimedOut(CallbackConsumerError):
 
 
 class ActivityTaskStartOutcome:
-    worker_name: Optional[str]
+    worker_name: str | None
 
-    def __init__(self, worker_name: Optional[str] = None):
+    def __init__(self, worker_name: str | None = None):
         self.worker_name = worker_name
 
 
 class ActivityTaskStartEndpoint:
     _next_activity_task_start_event: Final[Event]
-    _outcome: Optional[ActivityTaskStartOutcome]
+    _outcome: ActivityTaskStartOutcome | None
 
     def __init__(self):
         self._next_activity_task_start_event = Event()
 
-    def wait(self, timeout_seconds: float) -> Optional[ActivityTaskStartOutcome]:
+    def wait(self, timeout_seconds: float) -> ActivityTaskStartOutcome | None:
         self._next_activity_task_start_event.wait(timeout=timeout_seconds)
         return self._outcome
 
@@ -110,9 +110,9 @@ class ActivityTaskStartEndpoint:
 class CallbackEndpoint:
     callback_id: Final[CallbackId]
     _notify_event: Final[Event]
-    _outcome: Optional[CallbackOutcome]
-    consumer_error: Optional[CallbackConsumerError]
-    _heartbeat_endpoint: Optional[HeartbeatEndpoint]
+    _outcome: CallbackOutcome | None
+    consumer_error: CallbackConsumerError | None
+    _heartbeat_endpoint: HeartbeatEndpoint | None
 
     def __init__(self, callback_id: CallbackId):
         self.callback_id = callback_id
@@ -144,11 +144,11 @@ class CallbackEndpoint:
         self._heartbeat_endpoint.notify()
         return True
 
-    def wait(self, timeout: Optional[float] = None) -> Optional[CallbackOutcome]:
+    def wait(self, timeout: float | None = None) -> CallbackOutcome | None:
         self._notify_event.wait(timeout=timeout)
         return self._outcome
 
-    def get_outcome(self) -> Optional[CallbackOutcome]:
+    def get_outcome(self) -> CallbackOutcome | None:
         return self._outcome
 
     def report(self, consumer_error: CallbackConsumerError) -> None:
@@ -170,7 +170,7 @@ class ActivityCallbackEndpoint(CallbackEndpoint):
     def get_activity_task_start_endpoint(self) -> ActivityTaskStartEndpoint:
         return self._activity_task_start_endpoint
 
-    def notify_activity_task_start(self, worker_name: Optional[str]) -> None:
+    def notify_activity_task_start(self, worker_name: str | None) -> None:
         self._activity_task_start_endpoint.notify(ActivityTaskStartOutcome(worker_name=worker_name))
 
 
@@ -196,7 +196,7 @@ class CallbackPoolManager:
         self._activity_store = activity_store
         self._pool = OrderedDict()
 
-    def get(self, callback_id: CallbackId) -> Optional[CallbackEndpoint]:
+    def get(self, callback_id: CallbackId) -> CallbackEndpoint | None:
         return self._pool.get(callback_id)
 
     def add(self, callback_id: CallbackId) -> CallbackEndpoint:
@@ -212,7 +212,7 @@ class CallbackPoolManager:
         if callback_id in self._pool:
             raise ValueError("Duplicate callback token id value.")
 
-        maybe_activity: Optional[Activity] = self._activity_store.get(activity_arn)
+        maybe_activity: Activity | None = self._activity_store.get(activity_arn)
         if maybe_activity is None:
             raise ActivityDoesNotExist()
 
@@ -232,7 +232,7 @@ class CallbackPoolManager:
         if callback_endpoint is None:
             return False
 
-        consumer_error: Optional[CallbackConsumerError] = callback_endpoint.consumer_error
+        consumer_error: CallbackConsumerError | None = callback_endpoint.consumer_error
         if consumer_error is not None:
             raise CallbackNotifyConsumerError(callback_consumer_error=consumer_error)
 
@@ -244,7 +244,7 @@ class CallbackPoolManager:
         if callback_endpoint is None:
             return False
 
-        consumer_error: Optional[CallbackConsumerError] = callback_endpoint.consumer_error
+        consumer_error: CallbackConsumerError | None = callback_endpoint.consumer_error
         if consumer_error is not None:
             raise CallbackNotifyConsumerError(callback_consumer_error=consumer_error)
 

localstack/services/stepfunctions/asl/eval/environment.py

@@ -41,18 +41,18 @@ LOG = logging.getLogger(__name__)
 
 class Environment:
     _state_mutex: Final[threading.RLock()]
-    _program_state: Optional[ProgramState]
+    _program_state: ProgramState | None
     program_state_event: Final[threading.Event()]
 
     event_manager: EventManager
     event_history_context: Final[EventHistoryContext]
-    cloud_watch_logging_session: Final[Optional[CloudWatchLoggingSession]]
+    cloud_watch_logging_session: Final[CloudWatchLoggingSession | None]
     aws_execution_details: Final[AWSExecutionDetails]
     execution_type: Final[StateMachineType]
     callback_pool_manager: CallbackPoolManager
     map_run_record_pool_manager: MapRunRecordPoolManager
     activity_store: Final[dict[Arn, Activity]]
-    mock_test_case: Optional[MockTestCase] = None
+    mock_test_case: MockTestCase | None = None
 
     _frames: Final[list[Environment]]
     _is_frame: bool = False
@@ -68,10 +68,10 @@ class Environment:
         execution_type: StateMachineType,
         context: ContextObjectData,
         event_history_context: EventHistoryContext,
-        cloud_watch_logging_session: Optional[CloudWatchLoggingSession],
+        cloud_watch_logging_session: CloudWatchLoggingSession | None,
         activity_store: dict[Arn, Activity],
-        variable_store: Optional[VariableStore] = None,
-        mock_test_case: Optional[MockTestCase] = None,
+        variable_store: VariableStore | None = None,
+        mock_test_case: MockTestCase | None = None,
     ):
         super(Environment, self).__init__()
         self._state_mutex = threading.RLock()
@@ -101,7 +101,7 @@ class Environment:
 
     @classmethod
     def as_frame_of(
-        cls, env: Environment, event_history_frame_cache: Optional[EventHistoryContext] = None
+        cls, env: Environment, event_history_frame_cache: EventHistoryContext | None = None
     ) -> Environment:
         return Environment.as_inner_frame_of(
             env=env,
@@ -114,7 +114,7 @@ class Environment:
         cls,
         env: Environment,
         variable_store: VariableStore,
-        event_history_frame_cache: Optional[EventHistoryContext] = None,
+        event_history_frame_cache: EventHistoryContext | None = None,
     ) -> Environment:
         # Construct the frame's context object data.
         context = ContextObjectData(
@@ -153,8 +153,8 @@ class Environment:
         return frame
 
     @property
-    def next_state_name(self) -> Optional[str]:
-        next_state_name: Optional[str] = None
+    def next_state_name(self) -> str | None:
+        next_state_name: str | None = None
         program_state = self._program_state
         if isinstance(program_state, ProgramRunning):
             next_state_name = program_state.next_state_name
@@ -173,8 +173,8 @@ class Environment:
             )
 
     @property
-    def next_field_name(self) -> Optional[str]:
-        next_field_name: Optional[str] = None
+    def next_field_name(self) -> str | None:
+        next_field_name: str | None = None
         program_state = self._program_state
         if isinstance(program_state, ProgramRunning):
             next_field_name = program_state.next_field_name
@@ -220,7 +220,7 @@ class Environment:
             self.program_state_event.set()
             self.program_state_event.clear()
 
-    def set_stop(self, stop_date: Timestamp, cause: Optional[str], error: Optional[str]) -> None:
+    def set_stop(self, stop_date: Timestamp, cause: str | None, error: str | None) -> None:
         with self._state_mutex:
             if isinstance(self._program_state, ProgramRunning):
                 self._program_state = ProgramStopped(stop_date=stop_date, cause=cause, error=error)
@@ -229,16 +229,14 @@ class Environment:
                 self.program_state_event.set()
                 self.program_state_event.clear()
 
-    def open_frame(
-        self, event_history_context: Optional[EventHistoryContext] = None
-    ) -> Environment:
+    def open_frame(self, event_history_context: EventHistoryContext | None = None) -> Environment:
         with self._state_mutex:
             frame = self.as_frame_of(env=self, event_history_frame_cache=event_history_context)
             self._frames.append(frame)
             return frame
 
     def open_inner_frame(
-        self, event_history_context: Optional[EventHistoryContext] = None
+        self, event_history_context: EventHistoryContext | None = None
     ) -> Environment:
         with self._state_mutex:
             variable_store = VariableStore.as_inner_scope_of(

localstack/services/stepfunctions/asl/eval/evaluation_details.py

@@ -1,4 +1,4 @@
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.aws.api.stepfunctions import Arn, Definition, LongArn, StateMachineType
 
@@ -18,12 +18,10 @@ class ExecutionDetails:
     arn: Final[LongArn]
     name: Final[str]
     role_arn: Final[Arn]
-    inpt: Final[Optional[Any]]
+    inpt: Final[Any | None]
     start_time: Final[str]
 
-    def __init__(
-        self, arn: LongArn, name: str, role_arn: Arn, inpt: Optional[Any], start_time: str
-    ):
+    def __init__(self, arn: LongArn, name: str, role_arn: Arn, inpt: Any | None, start_time: str):
         self.arn = arn
         self.name = name
         self.role_arn = role_arn

localstack/services/stepfunctions/asl/eval/event/event_manager.py

@@ -4,7 +4,7 @@ import copy
 import datetime
 import logging
 import threading
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import (
     HistoryEvent,
@@ -61,9 +61,9 @@ class EventManager:
     _mutex: Final[threading.Lock]
     _event_id_gen: EventIdGenerator
     _history_event_list: Final[HistoryEventList]
-    _cloud_watch_logging_session: Final[Optional[CloudWatchLoggingSession]]
+    _cloud_watch_logging_session: Final[CloudWatchLoggingSession | None]
 
-    def __init__(self, cloud_watch_logging_session: Optional[CloudWatchLoggingSession] = None):
+    def __init__(self, cloud_watch_logging_session: CloudWatchLoggingSession | None = None):
         self._mutex = threading.Lock()
         self._event_id_gen = EventIdGenerator()
         self._history_event_list = list()
@@ -73,7 +73,7 @@ class EventManager:
         self,
         context: EventHistoryContext,
         event_type: HistoryEventType,
-        event_details: Optional[EventDetails] = None,
+        event_details: EventDetails | None = None,
         timestamp: Timestamp = None,
         update_source_event_id: bool = True,
     ) -> int:
@@ -105,7 +105,7 @@ class EventManager:
 
     @staticmethod
     def _get_current_timestamp() -> datetime.datetime:
-        return datetime.datetime.now(tz=datetime.timezone.utc)
+        return datetime.datetime.now(tz=datetime.UTC)
 
     @staticmethod
     def _create_history_event(
@@ -113,7 +113,7 @@ class EventManager:
         source_event_id: int,
         event_type: HistoryEventType,
         timestamp: datetime.datetime,
-        event_details: Optional[EventDetails],
+        event_details: EventDetails | None,
     ) -> HistoryEvent:
         history_event = HistoryEvent()
         if event_details is not None:
@@ -130,7 +130,7 @@ class EventManager:
         source_event_id: int,
         event_type: HistoryEventType,
         timestamp: datetime.datetime,
-        event_details: Optional[EventDetails],
+        event_details: EventDetails | None,
     ):
         history_event = self._create_history_event(
             event_id=event_id,
@@ -154,7 +154,7 @@ class EventManager:
         event_type: HistoryEventType,
         timestamp: datetime.datetime,
         execution_arn: LongArn,
-        event_details: Optional[EventDetails],
+        event_details: EventDetails | None,
         include_execution_data: bool,
     ) -> HistoryLog:
         log = HistoryLog(
@@ -184,7 +184,7 @@ class EventManager:
         source_event_id: int,
         event_type: HistoryEventType,
         timestamp: datetime.datetime,
-        event_details: Optional[EventDetails],
+        event_details: EventDetails | None,
     ):
         # No logging session for this execution.
         if self._cloud_watch_logging_session is None:

localstack/services/stepfunctions/asl/eval/event/logging.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import logging
 from datetime import datetime
-from typing import Final, NotRequired, Optional, TypedDict
+from typing import Final, NotRequired, TypedDict
 
 from botocore.client import BaseClient
 from botocore.exceptions import ClientError
@@ -111,7 +111,7 @@ class CloudWatchLoggingConfiguration:
     @staticmethod
     def extract_log_arn_parts_from(
         logging_configuration: LoggingConfiguration,
-    ) -> Optional[tuple[str, str, str]]:
+    ) -> tuple[str, str, str] | None:
         # Returns a tuple with: account_id, region, and log group name if the logging configuration
         # specifies a valid cloud watch log group arn, none otherwise.
 
@@ -155,7 +155,7 @@ class CloudWatchLoggingConfiguration:
     def from_logging_configuration(
         state_machine_arn: LongArn,
         logging_configuration: LoggingConfiguration,
-    ) -> Optional[CloudWatchLoggingConfiguration]:
+    ) -> CloudWatchLoggingConfiguration | None:
         log_level = logging_configuration.get("level", LogLevel.OFF)
         if log_level == LogLevel.OFF:
             return None

localstack/services/stepfunctions/asl/eval/program_state.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import ExecutionFailedEventDetails, Timestamp
 
@@ -12,16 +12,16 @@ class ProgramEnded(ProgramState):
 
 
 class ProgramStopped(ProgramState):
-    def __init__(self, stop_date: Timestamp, error: Optional[str], cause: Optional[str]):
+    def __init__(self, stop_date: Timestamp, error: str | None, cause: str | None):
         super().__init__()
         self.stop_date: Timestamp = stop_date
-        self.error: Optional[str] = error
-        self.cause: Optional[str] = cause
+        self.error: str | None = error
+        self.cause: str | None = cause
 
 
 class ProgramRunning(ProgramState):
-    _next_state_name: Optional[str]
-    _next_field_name: Optional[str]
+    _next_state_name: str | None
+    _next_field_name: str | None
 
     def __init__(self):
         super().__init__()
@@ -53,9 +53,9 @@ class ProgramRunning(ProgramState):
 
 
 class ProgramError(ProgramState):
-    error: Final[Optional[ExecutionFailedEventDetails]]
+    error: Final[ExecutionFailedEventDetails | None]
 
-    def __init__(self, error: Optional[ExecutionFailedEventDetails]):
+    def __init__(self, error: ExecutionFailedEventDetails | None):
         super().__init__()
         self.error = error
 

localstack/services/stepfunctions/asl/eval/states.py

@@ -1,5 +1,5 @@
 import copy
-from typing import Any, Final, NotRequired, Optional, TypedDict
+from typing import Any, Final, NotRequired, TypedDict
 
 from localstack.services.stepfunctions.asl.jsonata.jsonata import (
     VariableDeclarations,
@@ -18,7 +18,7 @@ _STATES_ERROR_OUTPUT_PREFIX: Final[str] = "$states.errorOutput"
 
 class ExecutionData(TypedDict):
     Id: str
-    Input: Optional[Any]
+    Input: Any | None
     Name: str
     RoleArn: str
     StartTime: str  # Format: ISO 8601.
@@ -43,7 +43,7 @@ class ItemData(TypedDict):
     # Contains the index number for the array item that is being currently processed.
     Index: int
     # Contains the array item being processed.
-    Value: Optional[Any]
+    Value: Any | None
 
 
 class MapData(TypedDict):
@@ -73,8 +73,8 @@ class ContextObject:
 class StatesData(TypedDict):
     input: Any
     context: ContextObjectData
-    result: NotRequired[Optional[Any]]
-    errorOutput: NotRequired[Optional[Any]]
+    result: NotRequired[Any | None]
+    errorOutput: NotRequired[Any | None]
 
 
 class States:
@@ -87,7 +87,7 @@ class States:
         self.context_object = ContextObject(context_object=context)
 
     @staticmethod
-    def _extract(query: Optional[str], data: Any) -> Any:
+    def _extract(query: str | None, data: Any) -> Any:
         if query is None:
             result = data
         else:
@@ -100,7 +100,7 @@ class States:
         jsonpath_states_query = "$." + query[1:]
         return self._extract(jsonpath_states_query, self._states_data)
 
-    def get_input(self, query: Optional[str] = None) -> Any:
+    def get_input(self, query: str | None = None) -> Any:
         return self._extract(query, self._states_data["input"])
 
     def reset(self, input_value: Any) -> None:
@@ -109,10 +109,10 @@ class States:
         self._states_data["result"] = None
         self._states_data["errorOutput"] = None
 
-    def get_context(self, query: Optional[str] = None) -> Any:
+    def get_context(self, query: str | None = None) -> Any:
         return self._extract(query, self._states_data["context"])
 
-    def get_result(self, query: Optional[str] = None) -> Any:
+    def get_result(self, query: str | None = None) -> Any:
         if "result" not in self._states_data:
             raise RuntimeError("Illegal access to $states.result")
         return self._extract(query, self._states_data["result"])
@@ -121,7 +121,7 @@ class States:
         clone_result = copy.deepcopy(result)
         self._states_data["result"] = clone_result
 
-    def get_error_output(self, query: Optional[str] = None) -> Any:
+    def get_error_output(self, query: str | None = None) -> Any:
         if "errorOutput" not in self._states_data:
             raise RuntimeError("Illegal access to $states.errorOutput")
         return self._extract(query, self._states_data["errorOutput"])
@@ -131,7 +131,7 @@ class States:
         self._states_data["errorOutput"] = clone_error_output
 
     def to_variable_declarations(
-        self, variable_references: Optional[set[VariableReference]] = None
+        self, variable_references: set[VariableReference] | None = None
     ) -> VariableDeclarations:
         if not variable_references or _STATES_PREFIX in variable_references:
             return encode_jsonata_variable_declarations(

localstack/services/stepfunctions/asl/eval/test_state/environment.py

@@ -1,7 +1,5 @@
 from __future__ import annotations
 
-from typing import Optional
-
 from localstack.aws.api.stepfunctions import Arn, InspectionData, StateMachineType
 from localstack.services.stepfunctions.asl.eval.environment import Environment
 from localstack.services.stepfunctions.asl.eval.evaluation_details import AWSExecutionDetails
@@ -32,7 +30,7 @@ class TestStateEnvironment(Environment):
         context: ContextObjectData,
         event_history_context: EventHistoryContext,
         activity_store: dict[Arn, Activity],
-        cloud_watch_logging_session: Optional[CloudWatchLoggingSession] = None,
+        cloud_watch_logging_session: CloudWatchLoggingSession | None = None,
     ):
         super().__init__(
             aws_execution_details=aws_execution_details,
@@ -47,7 +45,7 @@ class TestStateEnvironment(Environment):
     def as_frame_of(
         cls,
         env: TestStateEnvironment,
-        event_history_frame_cache: Optional[EventHistoryContext] = None,
+        event_history_frame_cache: EventHistoryContext | None = None,
     ) -> Environment:
         frame = super().as_frame_of(env=env, event_history_frame_cache=event_history_frame_cache)
         frame.inspection_data = env.inspection_data
@@ -57,7 +55,7 @@ class TestStateEnvironment(Environment):
         cls,
         env: TestStateEnvironment,
         variable_store: VariableStore,
-        event_history_frame_cache: Optional[EventHistoryContext] = None,
+        event_history_frame_cache: EventHistoryContext | None = None,
     ) -> Environment:
         frame = super().as_inner_frame_of(
             env=env,

localstack/services/stepfunctions/asl/eval/variable_store.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.jsonata.jsonata import (
     VariableDeclarations,
@@ -51,8 +51,8 @@ class VariableStore:
 
     _declaration_tracing: Final[set[str]]
 
-    _outer_variable_declaration_cache: Optional[VariableDeclarations]
-    _variable_declarations_cache: Optional[VariableDeclarations]
+    _outer_variable_declaration_cache: VariableDeclarations | None
+    _variable_declarations_cache: VariableDeclarations | None
 
     def __init__(self):
         self._outer_scope = dict()