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

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

@@ -41,24 +41,24 @@ 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
 
-    heap: dict[str, Any] = dict()
-    stack: list[Any] = list()
+    heap: dict[str, Any] = {}
+    stack: list[Any] = []
     states: Final[States]
     variable_store: Final[VariableStore]
 
@@ -68,12 +68,12 @@ 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__()
+        super().__init__()
         self._state_mutex = threading.RLock()
         self._program_state = None
         self.program_state_event = threading.Event()
@@ -91,17 +91,17 @@ class Environment:
 
         self.mock_test_case = mock_test_case
 
-        self._frames = list()
+        self._frames = []
         self._is_frame = False
 
-        self.heap = dict()
-        self.stack = list()
+        self.heap = {}
+        self.stack = []
         self.states = States(context=context)
         self.variable_store = variable_store or VariableStore()
 
     @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(
@@ -148,13 +148,13 @@ class Environment:
             )
         frame.callback_pool_manager = env.callback_pool_manager
         frame.map_run_record_pool_manager = env.map_run_record_pool_manager
-        frame.heap = dict()
+        frame.heap = {}
         frame._program_state = copy.deepcopy(env._program_state)
         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,19 +61,19 @@ 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()
+        self._history_event_list = []
         self._cloud_watch_logging_session = cloud_watch_logging_session
 
     def add_event(
         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(
@@ -143,7 +143,7 @@ class States:
             "result": _STATES_RESULT_PREFIX,
             "errorOutput": _STATES_ERROR_OUTPUT_PREFIX,
         }
-        sub_states = dict()
+        sub_states = {}
         for variable_reference in variable_references:
             if not candidate_sub_states:
                 break

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,12 +51,12 @@ 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()
-        self._inner_scope = dict()
+        self._outer_scope = {}
+        self._inner_scope = {}
         self._declaration_tracing = set()
         self._outer_variable_declaration_cache = None
         self._variable_declarations_cache = None
@@ -73,7 +73,7 @@ class VariableStore:
 
     # TODO: add typing when this available in service init.
     def get_assigned_variables(self) -> dict[str, str]:
-        assigned_variables: dict[str, str] = dict()
+        assigned_variables: dict[str, str] = {}
         for traced_declaration_identifier in self._declaration_tracing:
             traced_declaration_value = self.get(traced_declaration_identifier)
             if isinstance(traced_declaration_value, str):

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

@@ -2,11 +2,12 @@ from __future__ import annotations
 
 import json
 import re
+from collections.abc import Callable
 from pathlib import Path
-from typing import Any, Callable, Final, Optional
+from typing import Any, Final
 
 import jpype
-import jpype.imports
+import jpype.imports  # noqa # Required for JVM Java class imports
 
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
 from localstack.services.stepfunctions.packages import jpype_jsonata_package
@@ -45,9 +46,9 @@ _EXPRESSION_CLOSE_SYMBOL: Final[str] = ")"
 
 class JSONataException(Exception):
     error: Final[str]
-    details: Optional[str]
+    details: str | None
 
-    def __init__(self, error: str, details: Optional[str]):
+    def __init__(self, error: str, details: str | None):
         self.error = error
         self.details = details
 
@@ -105,7 +106,7 @@ class _JSONataJVMBridge:
 
 # Lazy initialization of the `eval_jsonata` function pointer.
 # This ensures the JVM is only started when JSONata functionality is needed.
-_eval_jsonata: Optional[Callable[[JSONataExpression], Any]] = None
+_eval_jsonata: Callable[[JSONataExpression], Any] | None = None
 
 
 def eval_jsonata_expression(jsonata_expression: JSONataExpression) -> Any:
@@ -144,7 +145,7 @@ def extract_jsonata_variable_references(
 def encode_jsonata_variable_declarations(
     bindings: dict[VariableReference, Any],
 ) -> VariableDeclarations:
-    declarations_parts: list[str] = list()
+    declarations_parts: list[str] = []
     for variable_reference, value in bindings.items():
         if isinstance(value, str):
             value_str_lit = f'"{value}"'

localstack/services/stepfunctions/asl/parse/asl_parser.py

@@ -15,7 +15,7 @@ class SyntaxErrorListener(ErrorListener):
 
     def __init__(self):
         super().__init__()
-        self.errors = list()
+        self.errors = []
 
     def syntaxError(self, recognizer, offending_symbol, line, column, message, exception):
         log_parts = [f"line {line}:{column}"]

localstack/services/stepfunctions/asl/parse/intrinsic/preprocessor.py

@@ -1,5 +1,4 @@
 import re
-from typing import Optional
 
 from antlr4.tree.Tree import ParseTree, TerminalNodeImpl
 
@@ -86,9 +85,9 @@ class Preprocessor(ASLIntrinsicParserVisitor):
         return ArgumentLiteral(definition_value=bool_val)
 
     def visitFunc_arg_list(self, ctx: ASLIntrinsicParser.Func_arg_listContext) -> ArgumentList:
-        arguments: list[Argument] = list()
+        arguments: list[Argument] = []
         for child in ctx.children:
-            cmp: Optional[Component] = self.visit(child)
+            cmp: Component | None = self.visit(child)
             if isinstance(cmp, Argument):
                 arguments.append(cmp)
         return ArgumentList(arguments=arguments)