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

localstack/services/stepfunctions/backend/state_machine.py

@@ -4,7 +4,7 @@ import abc
 import datetime
 import json
 from collections import OrderedDict
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import (
     Arn,
@@ -37,15 +37,15 @@ from localstack.utils.strings import long_uid
 class StateMachineInstance:
     name: Name
     arn: Arn
-    revision_id: Optional[RevisionId]
+    revision_id: RevisionId | None
     definition: Definition
     role_arn: Arn
     create_date: datetime.datetime
     sm_type: StateMachineType
     logging_config: LoggingConfiguration
-    cloud_watch_logging_configuration: Optional[CloudWatchLoggingConfiguration]
-    tags: Optional[TagList]
-    tracing_config: Optional[TracingConfiguration]
+    cloud_watch_logging_configuration: CloudWatchLoggingConfiguration | None
+    tags: TagList | None
+    tracing_config: TracingConfiguration | None
 
     def __init__(
         self,
@@ -54,18 +54,18 @@ class StateMachineInstance:
         definition: Definition,
         role_arn: Arn,
         logging_config: LoggingConfiguration,
-        cloud_watch_logging_configuration: Optional[CloudWatchLoggingConfiguration] = None,
-        create_date: Optional[datetime.datetime] = None,
-        sm_type: Optional[StateMachineType] = None,
-        tags: Optional[TagList] = None,
-        tracing_config: Optional[TracingConfiguration] = None,
+        cloud_watch_logging_configuration: CloudWatchLoggingConfiguration | None = None,
+        create_date: datetime.datetime | None = None,
+        sm_type: StateMachineType | None = None,
+        tags: TagList | None = None,
+        tracing_config: TracingConfiguration | None = None,
     ):
         self.name = name
         self.arn = arn
         self.revision_id = None
         self.definition = definition
         self.role_arn = role_arn
-        self.create_date = create_date or datetime.datetime.now(tz=datetime.timezone.utc)
+        self.create_date = create_date or datetime.datetime.now(tz=datetime.UTC)
         self.sm_type = sm_type or StateMachineType.STANDARD
         self.logging_config = logging_config
         self.cloud_watch_logging_configuration = cloud_watch_logging_configuration
@@ -106,7 +106,7 @@ class TestStateMachine(StateMachineInstance):
         arn: Arn,
         definition: Definition,
         role_arn: Arn,
-        create_date: Optional[datetime.datetime] = None,
+        create_date: datetime.datetime | None = None,
     ):
         super().__init__(
             name,
@@ -125,7 +125,7 @@ class TestStateMachine(StateMachineInstance):
 
 
 class TagManager:
-    _tags: Final[dict[str, Optional[str]]]
+    _tags: Final[dict[str, str | None]]
 
     def __init__(self):
         self._tags = OrderedDict()
@@ -154,7 +154,7 @@ class TagManager:
             self._tags.pop(key, None)
 
     def to_tag_list(self) -> TagList:
-        tag_list = list()
+        tag_list = []
         for key, value in self._tags.items():
             tag_list.append(Tag(key=key, value=value))
         return tag_list
@@ -173,11 +173,11 @@ class StateMachineRevision(StateMachineInstance):
         definition: Definition,
         role_arn: Arn,
         logging_config: LoggingConfiguration,
-        cloud_watch_logging_configuration: Optional[CloudWatchLoggingConfiguration],
-        create_date: Optional[datetime.datetime] = None,
-        sm_type: Optional[StateMachineType] = None,
-        tags: Optional[TagList] = None,
-        tracing_config: Optional[TracingConfiguration] = None,
+        cloud_watch_logging_configuration: CloudWatchLoggingConfiguration | None,
+        create_date: datetime.datetime | None = None,
+        sm_type: StateMachineType | None = None,
+        tags: TagList | None = None,
+        tracing_config: TracingConfiguration | None = None,
     ):
         super().__init__(
             name,
@@ -191,7 +191,7 @@ class StateMachineRevision(StateMachineInstance):
             tags,
             tracing_config,
         )
-        self.versions = dict()
+        self.versions = {}
         self._version_number = 0
         self.tag_manager = TagManager()
         if tags:
@@ -200,10 +200,10 @@ class StateMachineRevision(StateMachineInstance):
 
     def create_revision(
         self,
-        definition: Optional[str],
-        role_arn: Optional[Arn],
-        logging_configuration: Optional[LoggingConfiguration],
-    ) -> Optional[RevisionId]:
+        definition: str | None,
+        role_arn: Arn | None,
+        logging_configuration: LoggingConfiguration | None,
+    ) -> RevisionId | None:
         update_definition = definition and json.loads(definition) != json.loads(self.definition)
         if update_definition:
             self.definition = definition
@@ -228,7 +228,7 @@ class StateMachineRevision(StateMachineInstance):
 
         return self.revision_id
 
-    def create_version(self, description: Optional[str]) -> Optional[StateMachineVersion]:
+    def create_version(self, description: str | None) -> StateMachineVersion | None:
         if self.revision_id not in self.versions:
             self._version_number += 1
             version = StateMachineVersion(
@@ -259,10 +259,10 @@ class StateMachineRevision(StateMachineInstance):
 class StateMachineVersion(StateMachineInstance):
     source_arn: Arn
     version: int
-    description: Optional[str]
+    description: str | None
 
     def __init__(
-        self, state_machine_revision: StateMachineRevision, version: int, description: Optional[str]
+        self, state_machine_revision: StateMachineRevision, version: int, description: str | None
     ):
         version_arn = f"{state_machine_revision.arn}:{version}"
         super().__init__(
@@ -270,7 +270,7 @@ class StateMachineVersion(StateMachineInstance):
             arn=version_arn,
             definition=state_machine_revision.definition,
             role_arn=state_machine_revision.role_arn,
-            create_date=datetime.datetime.now(tz=datetime.timezone.utc),
+            create_date=datetime.datetime.now(tz=datetime.UTC),
             sm_type=state_machine_revision.sm_type,
             logging_config=state_machine_revision.logging_config,
             cloud_watch_logging_configuration=state_machine_revision.cloud_watch_logging_configuration,

localstack/services/stepfunctions/backend/test_state/execution.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import logging
 import threading
-from typing import Optional
 
 from localstack.aws.api.stepfunctions import (
     Arn,
@@ -37,8 +36,8 @@ LOG = logging.getLogger(__name__)
 
 
 class TestStateExecution(Execution):
-    exec_worker: Optional[TestStateExecutionWorker]
-    next_state: Optional[str]
+    exec_worker: TestStateExecutionWorker | None
+    next_state: str | None
 
     class TestCaseExecutionWorkerCommunication(BaseExecutionWorkerCommunication):
         _execution: TestStateExecution
@@ -62,7 +61,7 @@ class TestStateExecution(Execution):
         state_machine: StateMachineInstance,
         start_date: Timestamp,
         activity_store: dict[Arn, Activity],
-        input_data: Optional[dict] = None,
+        input_data: dict | None = None,
     ):
         super().__init__(
             name=name,

localstack/services/stepfunctions/backend/test_state/execution_worker.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from localstack.services.stepfunctions.asl.component.eval_component import EvalComponent
 from localstack.services.stepfunctions.asl.eval.environment import Environment
 from localstack.services.stepfunctions.asl.eval.event.event_manager import (
@@ -18,7 +16,7 @@ from localstack.services.stepfunctions.backend.execution_worker import SyncExecu
 
 
 class TestStateExecutionWorker(SyncExecutionWorker):
-    env: Optional[TestStateEnvironment]
+    env: TestStateEnvironment | None
 
     def _get_evaluation_entrypoint(self) -> EvalComponent:
         return TestStateAmazonStateLanguageParser.parse(

localstack/services/stepfunctions/mocking/mock_config.py

@@ -1,5 +1,5 @@
 import abc
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.services.stepfunctions.mocking.mock_config_file import (
     RawMockConfig,
@@ -56,7 +56,7 @@ class StateMockedResponses:
     ):
         self.state_name = state_name
         self.mocked_response_name = mocked_response_name
-        self.mocked_responses = list()
+        self.mocked_responses = []
         last_range_end: int = -1
         mocked_responses_sorted = sorted(mocked_responses, key=lambda mr: mr.range_start)
         for mocked_response in mocked_responses_sorted:
@@ -87,7 +87,7 @@ class MockTestCase:
     ):
         self.state_machine_name = state_machine_name
         self.test_case_name = test_case_name
-        self.state_mocked_responses = dict()
+        self.state_mocked_responses = {}
         for state_mocked_response in state_mocked_responses_list:
             state_name = state_mocked_response.state_name
             if state_name in self.state_mocked_responses:
@@ -144,14 +144,14 @@ def _mocked_response_from_raw(
 def _mocked_responses_from_raw(
     mocked_response_name: str, raw_mock_config: RawMockConfig
 ) -> list[MockedResponse]:
-    raw_response_models: Optional[dict[str, RawResponseModel]] = (
-        raw_mock_config.MockedResponses.get(mocked_response_name)
+    raw_response_models: dict[str, RawResponseModel] | None = raw_mock_config.MockedResponses.get(
+        mocked_response_name
     )
     if not raw_response_models:
         raise RuntimeError(
             f"No definitions for mocked response '{mocked_response_name}' in the mock configuration file."
         )
-    mocked_responses: list[MockedResponse] = list()
+    mocked_responses: list[MockedResponse] = []
     for raw_response_model_range, raw_response_model in raw_response_models.items():
         mocked_response: MockedResponse = _mocked_response_from_raw(
             raw_response_model_range=raw_response_model_range, raw_response_model=raw_response_model
@@ -187,7 +187,7 @@ def _mock_test_case_from_raw(
             f"No definitions for test case '{test_case_name}' and "
             f"state machine '{state_machine_name}' in the mock configuration file."
         )
-    state_mocked_responses_list: list[StateMockedResponses] = list()
+    state_mocked_responses_list: list[StateMockedResponses] = []
     for state_name, mocked_response_name in test_case.root.items():
         state_mocked_responses = _state_mocked_responses_from_raw(
             state_name=state_name,
@@ -202,8 +202,8 @@ def _mock_test_case_from_raw(
     )
 
 
-def load_mock_test_case_for(state_machine_name: str, test_case_name: str) -> Optional[MockTestCase]:
-    raw_mock_config: Optional[RawMockConfig] = _load_sfn_raw_mock_config()
+def load_mock_test_case_for(state_machine_name: str, test_case_name: str) -> MockTestCase | None:
+    raw_mock_config: RawMockConfig | None = _load_sfn_raw_mock_config()
     if raw_mock_config is None:
         return None
     mock_test_case: MockTestCase = _mock_test_case_from_raw(

localstack/services/stepfunctions/mocking/mock_config_file.py

@@ -2,7 +2,7 @@ import logging
 import os
 from functools import lru_cache
 from json import JSONDecodeError
-from typing import Any, Dict, Final, Optional
+from typing import Any, Final, Optional
 
 from pydantic import BaseModel, RootModel, ValidationError, model_validator
 
@@ -44,8 +44,8 @@ class RawResponseModel(BaseModel):
 
     model_config = {"frozen": True}
 
-    Return: Optional[RawReturnResponse] = None
-    Throw: Optional[RawThrowResponse] = None
+    Return: RawReturnResponse | None = None
+    Throw: RawThrowResponse | None = None
 
     @model_validator(mode="before")
     def validate_response(cls, data: dict) -> dict:
@@ -56,7 +56,7 @@ class RawResponseModel(BaseModel):
         return data
 
 
-class RawTestCase(RootModel[Dict[str, str]]):
+class RawTestCase(RootModel[dict[str, str]]):
     """
     Represents an individual test case.
     The keys are state names (e.g., 'LambdaState', 'SQSState')
@@ -73,7 +73,7 @@ class RawStateMachine(BaseModel):
 
     model_config = {"frozen": True}
 
-    TestCases: Dict[str, RawTestCase]
+    TestCases: dict[str, RawTestCase]
 
 
 class RawMockConfig(BaseModel):
@@ -86,8 +86,8 @@ class RawMockConfig(BaseModel):
 
     model_config = {"frozen": True}
 
-    StateMachines: Dict[str, RawStateMachine]
-    MockedResponses: Dict[str, Dict[str, RawResponseModel]]
+    StateMachines: dict[str, RawStateMachine]
+    MockedResponses: dict[str, dict[str, RawResponseModel]]
 
 
 @lru_cache(maxsize=1)
@@ -119,11 +119,11 @@ def _read_sfn_raw_mock_config(file_path: str, modified_epoch: int) -> Optional[R
         - Logging is used to capture warnings if file access or parsing fails.
     """
     try:
-        with open(file_path, "r") as df:
+        with open(file_path) as df:
             mock_config_str = df.read()
         mock_config: RawMockConfig = RawMockConfig.model_validate_json(mock_config_str)
         return mock_config
-    except (OSError, IOError) as file_error:
+    except OSError as file_error:
         LOG.error("Failed to open mock configuration file '%s'. Error: %s", file_path, file_error)
         return None
     except ValidationError as validation_error:
@@ -168,7 +168,7 @@ def _read_sfn_raw_mock_config(file_path: str, modified_epoch: int) -> Optional[R
         return None
 
 
-def _load_sfn_raw_mock_config() -> Optional[RawMockConfig]:
+def _load_sfn_raw_mock_config() -> RawMockConfig | None:
     configuration_file_path = config.SFN_MOCK_CONFIG
     if not configuration_file_path:
         return None

localstack/services/stepfunctions/packages.py

@@ -1,6 +1,6 @@
-from localstack.packages import Package, PackageInstaller
+from localstack.packages import InstallTarget, Package, PackageInstaller
 from localstack.packages.core import MavenPackageInstaller
-from localstack.packages.java import JavaInstallerMixin
+from localstack.packages.java import JavaInstallerMixin, java_package
 
 JSONATA_DEFAULT_VERSION = "0.9.7"
 JACKSON_DEFAULT_VERSION = "2.16.2"
@@ -12,9 +12,6 @@ class JSONataPackage(Package):
     def __init__(self):
         super().__init__("JSONataLibs", JSONATA_DEFAULT_VERSION)
 
-        # Match the dynamodb-local JRE version to reduce the LocalStack image size by sharing the same JRE version
-        self.java_version = "21"
-
     def get_versions(self) -> list[str]:
         return list(JSONATA_JACKSON_VERSION_STORE.keys())
 
@@ -25,6 +22,10 @@ class JSONataPackage(Package):
 class JSONataPackageInstaller(JavaInstallerMixin, MavenPackageInstaller):
     def __init__(self, version: str):
         jackson_version = JSONATA_JACKSON_VERSION_STORE[version]
+
+        # Match the dynamodb-local JRE version to reduce the LocalStack image size by sharing the same JRE version
+        self.java_version = "21"
+
         super().__init__(
             f"pkg:maven/com.dashjoin/jsonata@{version}",
             # jackson-databind is imported in jsonata.py as "from com.fasterxml.jackson.databind import ObjectMapper"
@@ -35,5 +36,13 @@ class JSONataPackageInstaller(JavaInstallerMixin, MavenPackageInstaller):
             f"pkg:maven/com.fasterxml.jackson.core/jackson-databind@{jackson_version}",
         )
 
+    def _prepare_installation(self, target: InstallTarget) -> None:
+        # override to install correct java version
+        java_package.get_installer(self.java_version).install(target)
+
+    def get_java_home(self) -> str | None:
+        """Override to use the specific Java version"""
+        return java_package.get_installer(self.java_version).get_java_home()
+
 
 jpype_jsonata_package = JSONataPackage()

localstack/services/stepfunctions/provider.py

@@ -4,7 +4,7 @@ import json
 import logging
 import re
 import time
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api import CommonServiceException, RequestContext
 from localstack.aws.api.stepfunctions import (
@@ -275,7 +275,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             )
 
     def _get_execution(self, context: RequestContext, execution_arn: Arn) -> Execution:
-        execution: Optional[Execution] = self.get_store(context).executions.get(execution_arn)
+        execution: Execution | None = self.get_store(context).executions.get(execution_arn)
         if not execution:
             raise ExecutionDoesNotExist(f"Execution Does Not Exist: '{execution_arn}'")
         return execution
@@ -283,7 +283,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
     def _get_executions(
         self,
         context: RequestContext,
-        execution_status: Optional[ExecutionStatus] = None,
+        execution_status: ExecutionStatus | None = None,
     ):
         store = self.get_store(context)
         execution: list[Execution] = list(store.executions.values())
@@ -297,9 +297,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         return execution
 
     def _get_activity(self, context: RequestContext, activity_arn: Arn) -> Activity:
-        maybe_activity: Optional[Activity] = self.get_store(context).activities.get(
-            activity_arn, None
-        )
+        maybe_activity: Activity | None = self.get_store(context).activities.get(activity_arn, None)
         if maybe_activity is None:
             raise ActivityDoesNotExist(f"Activity Does Not Exist: '{activity_arn}'")
         return maybe_activity
@@ -312,7 +310,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         state_machine_type: StateMachineType,
         logging_configuration: LoggingConfiguration,
         tracing_configuration: TracingConfiguration,
-    ) -> Optional[StateMachineRevision]:
+    ) -> StateMachineRevision | None:
         # CreateStateMachine's idempotency check is based on the state machine name, definition, type,
         # LoggingConfiguration and TracingConfiguration.
         # If a following request has a different roleArn or tags, Step Functions will ignore these differences and
@@ -338,11 +336,11 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
 
     def _idempotent_start_execution(
         self,
-        execution: Optional[Execution],
+        execution: Execution | None,
         state_machine: StateMachineInstance,
         name: Name,
         input_data: SensitiveData,
-    ) -> Optional[Execution]:
+    ) -> Execution | None:
         # StartExecution is idempotent for STANDARD workflows. For a STANDARD workflow,
         # if you call StartExecution with the same name and input as a running execution,
         # the call succeeds and return the same response as the original request.
@@ -366,9 +364,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             message=f"Execution Already Exists: '{execution.exec_arn}'",
         )
 
-    def _revision_by_name(
-        self, context: RequestContext, name: str
-    ) -> Optional[StateMachineInstance]:
+    def _revision_by_name(self, context: RequestContext, name: str) -> StateMachineInstance | None:
         state_machines: list[StateMachineInstance] = list(
             self.get_store(context).state_machines.values()
         )
@@ -445,7 +441,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
 
         # CreateStateMachine is an idempotent API. Subsequent requests won't create a duplicate resource if it was
         # already created.
-        idem_state_machine: Optional[StateMachineRevision] = self._idempotent_revision(
+        idem_state_machine: StateMachineRevision | None = self._idempotent_revision(
             context=context,
             name=state_machine_name,
             definition=state_machine_definition,
@@ -460,7 +456,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             )
 
         # Assert this state machine name is unique.
-        state_machine_with_name: Optional[StateMachineRevision] = self._revision_by_name(
+        state_machine_with_name: StateMachineRevision | None = self._revision_by_name(
             context=context, name=state_machine_name
         )
         if state_machine_with_name is not None:
@@ -690,9 +686,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         self, context: RequestContext, state_machine_alias_arn: Arn, **kwargs
     ) -> DescribeStateMachineAliasOutput:
         self._validate_state_machine_alias_arn(state_machine_alias_arn=state_machine_alias_arn)
-        alias: Optional[Alias] = self.get_store(context=context).aliases.get(
-            state_machine_alias_arn
-        )
+        alias: Alias | None = self.get_store(context=context).aliases.get(state_machine_alias_arn)
         if alias is None:
             # TODO: assemble the correct exception
             raise ValidationException()
@@ -778,9 +772,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         return state_machine_arn.split("#")[0]
 
     @staticmethod
-    def _get_mock_test_case(
-        state_machine_arn: str, state_machine_name: str
-    ) -> Optional[MockTestCase]:
+    def _get_mock_test_case(state_machine_arn: str, state_machine_name: str) -> MockTestCase | None:
         """Extract and load a mock test case from a state machine ARN if present."""
         parts = state_machine_arn.split("#")
         if len(parts) != 2:
@@ -813,9 +805,9 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         base_arn = self._get_state_machine_arn(state_machine_arn)
         store = self.get_store(context=context)
 
-        alias: Optional[Alias] = store.aliases.get(base_arn)
+        alias: Alias | None = store.aliases.get(base_arn)
         alias_sample_state_machine_version_arn = alias.sample() if alias is not None else None
-        unsafe_state_machine: Optional[StateMachineInstance] = store.state_machines.get(
+        unsafe_state_machine: StateMachineInstance | None = store.state_machines.get(
             alias_sample_state_machine_version_arn or base_arn
         )
         if not unsafe_state_machine:
@@ -825,7 +817,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         state_machine_clone = copy.deepcopy(unsafe_state_machine)
 
         if input is None:
-            input_data = dict()
+            input_data = {}
         else:
             try:
                 input_data = json.loads(input)
@@ -875,7 +867,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             region_name=context.region,
             state_machine=state_machine_clone,
             state_machine_alias_arn=alias.state_machine_alias_arn if alias is not None else None,
-            start_date=datetime.datetime.now(tz=datetime.timezone.utc),
+            start_date=datetime.datetime.now(tz=datetime.UTC),
             cloud_watch_logging_session=cloud_watch_logging_session,
             input_data=input_data,
             trace_header=trace_header,
@@ -901,7 +893,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         self._validate_state_machine_arn(state_machine_arn)
 
         base_arn = self._get_state_machine_arn(state_machine_arn)
-        unsafe_state_machine: Optional[StateMachineInstance] = self.get_store(
+        unsafe_state_machine: StateMachineInstance | None = self.get_store(
             context
         ).state_machines.get(base_arn)
         if not unsafe_state_machine:
@@ -914,7 +906,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         state_machine_clone = copy.deepcopy(unsafe_state_machine)
 
         if input is None:
-            input_data = dict()
+            input_data = {}
         else:
             try:
                 input_data = json.loads(input)
@@ -950,7 +942,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             account_id=context.account_id,
             region_name=context.region,
             state_machine=state_machine_clone,
-            start_date=datetime.datetime.now(tz=datetime.timezone.utc),
+            start_date=datetime.datetime.now(tz=datetime.UTC),
             cloud_watch_logging_session=cloud_watch_logging_session,
             input_data=input_data,
             trace_header=trace_header,
@@ -980,7 +972,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
 
     @staticmethod
     def _list_execution_filter(
-        ex: Execution, state_machine_arn: str, status_filter: Optional[str]
+        ex: Execution, state_machine_arn: str, status_filter: str | None
     ) -> bool:
         state_machine_reference_arn_set = {ex.state_machine_arn, ex.state_machine_version_arn}
         if state_machine_arn not in state_machine_reference_arn_set:
@@ -1105,7 +1097,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         if not isinstance(state_machine_revision, StateMachineRevision):
             raise InvalidArn(f"Invalid arn: {state_machine_arn}")
 
-        state_machine_aliases: StateMachineAliasList = list()
+        state_machine_aliases: StateMachineAliasList = []
         valid_token_found = next_token is None
 
         for alias in state_machine_revision.aliases:
@@ -1149,7 +1141,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         if not isinstance(state_machine_revision, StateMachineRevision):
             raise InvalidArn(f"Invalid arn: {state_machine_arn}")
 
-        state_machine_version_items = list()
+        state_machine_version_items = []
         for version_arn in state_machine_revision.versions.values():
             state_machine_version = state_machines[version_arn]
             if isinstance(state_machine_version, StateMachineVersion):
@@ -1245,7 +1237,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         if (
             state_machine_revision := state_machines.get(state_machine_version.source_arn)
         ) and isinstance(state_machine_revision, StateMachineRevision):
-            referencing_alias_names: list[str] = list()
+            referencing_alias_names: list[str] = []
             for alias in state_machine_revision.aliases:
                 if alias.is_router_for(state_machine_version_arn=state_machine_version_arn):
                     referencing_alias_names.append(alias.name)
@@ -1275,7 +1267,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         if execution.sm_type != StateMachineType.STANDARD:
             self._raise_resource_type_not_in_context(resource_type=execution.sm_type)
 
-        stop_date = datetime.datetime.now(tz=datetime.timezone.utc)
+        stop_date = datetime.datetime.now(tz=datetime.UTC)
         execution.stop(stop_date=stop_date, cause=cause, error=error)
         return StopExecutionOutput(stopDate=stop_date)
 
@@ -1328,9 +1320,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
                 target_revision_id = revision_id or state_machine.revision_id
                 version_arn = state_machine.versions[target_revision_id]
 
-        update_output = UpdateStateMachineOutput(
-            updateDate=datetime.datetime.now(tz=datetime.timezone.utc)
-        )
+        update_output = UpdateStateMachineOutput(updateDate=datetime.datetime.now(tz=datetime.UTC))
         if revision_id is not None:
             update_output["revisionId"] = revision_id
         if version_arn is not None:
@@ -1437,7 +1427,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
     ) -> DescribeMapRunOutput:
         store = self.get_store(context)
         for execution in store.executions.values():
-            map_run_record: Optional[MapRunRecord] = (
+            map_run_record: MapRunRecord | None = (
                 execution.exec_worker.env.map_run_record_pool_manager.get(map_run_arn)
             )
             if map_run_record is not None:
@@ -1477,7 +1467,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         # TODO: investigate behaviour of empty requests.
         store = self.get_store(context)
         for execution in store.executions.values():
-            map_run_record: Optional[MapRunRecord] = (
+            map_run_record: MapRunRecord | None = (
                 execution.exec_worker.env.map_run_record_pool_manager.get(map_run_arn)
             )
             if map_run_record is not None:
@@ -1507,7 +1497,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             definition=definition, static_analysers=[TestStateStaticAnalyser()]
         )
 
-        name: Optional[Name] = f"TestState-{short_uid()}"
+        name: Name | None = f"TestState-{short_uid()}"
         arn = stepfunctions_state_machine_arn(
             name=name, account_id=context.account_id, region_name=context.region
         )
@@ -1527,7 +1517,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
             account_id=context.account_id,
             region_name=context.region,
             state_machine=state_machine,
-            start_date=datetime.datetime.now(tz=datetime.timezone.utc),
+            start_date=datetime.datetime.now(tz=datetime.UTC),
             input_data=input_json,
             activity_store=self.get_store(context).activities,
         )
@@ -1591,7 +1581,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         self,
         context: RequestContext,
         task_token: TaskToken,
-        worker_name: Optional[Name],
+        worker_name: Name | None,
     ) -> None:
         executions: list[Execution] = self._get_executions(context)
         for execution in executions:
@@ -1604,7 +1594,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         raise InvalidToken()
 
     @staticmethod
-    def _pull_activity_task(activity: Activity) -> Optional[ActivityTask]:
+    def _pull_activity_task(activity: Activity) -> ActivityTask | None:
         seconds_left = 60
         while seconds_left > 0:
             try:
@@ -1624,7 +1614,7 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         self._validate_activity_arn(activity_arn)
 
         activity = self._get_activity(context=context, activity_arn=activity_arn)
-        maybe_task: Optional[ActivityTask] = self._pull_activity_task(activity=activity)
+        maybe_task: ActivityTask | None = self._pull_activity_task(activity=activity)
         if maybe_task is not None:
             self._send_activity_task_started(
                 context, maybe_task.task_token, worker_name=worker_name
@@ -1645,13 +1635,13 @@ class StepFunctionsProvider(StepfunctionsApi, ServiceLifecycleHook):
         state_machine_type: StateMachineType = request.get("type", StateMachineType.STANDARD)
         definition: str = request["definition"]
 
-        static_analysers = list()
+        static_analysers = []
         if state_machine_type == StateMachineType.STANDARD:
             static_analysers.append(StaticAnalyser())
         else:
             static_analysers.append(ExpressStaticAnalyser())
 
-        diagnostics: ValidateStateMachineDefinitionDiagnosticList = list()
+        diagnostics: ValidateStateMachineDefinitionDiagnosticList = []
         try:
             StepFunctionsProvider._validate_definition(
                 definition=definition, static_analysers=static_analysers