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

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

@@ -2,7 +2,8 @@ import abc
 import json
 import threading
 import time
-from typing import Any, Callable, Final, Optional
+from collections.abc import Callable
+from typing import Any, Final
 
 from localstack.aws.api.stepfunctions import (
     HistoryEventExecutionDataDetails,
@@ -67,7 +68,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         raise RuntimeError(
             f"Unsupported .sync callback procedure in resource {self.resource.resource_arn}"
         )
@@ -78,7 +79,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         raise RuntimeError(
             f"Unsupported .sync2 callback procedure in resource {self.resource.resource_arn}"
         )
@@ -88,9 +89,9 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         env: Environment,
         timeout_seconds: int,
         callback_endpoint: CallbackEndpoint,
-        heartbeat_endpoint: Optional[HeartbeatEndpoint],
+        heartbeat_endpoint: HeartbeatEndpoint | None,
     ) -> CallbackOutcome:
-        outcome: Optional[CallbackOutcome]
+        outcome: CallbackOutcome | None
         if heartbeat_endpoint is not None:
             outcome = self._wait_for_task_token_heartbeat(
                 env, callback_endpoint, heartbeat_endpoint
@@ -104,12 +105,12 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
     def _eval_sync(
         self,
         env: Environment,
-        sync_resolver: Callable[[], Optional[Any]],
-        timeout_seconds: Optional[int],
-        callback_endpoint: Optional[CallbackEndpoint],
-        heartbeat_endpoint: Optional[HeartbeatEndpoint],
+        sync_resolver: Callable[[], Any | None],
+        timeout_seconds: int | None,
+        callback_endpoint: CallbackEndpoint | None,
+        heartbeat_endpoint: HeartbeatEndpoint | None,
     ) -> CallbackOutcome | Any:
-        callback_output: Optional[CallbackOutcome] = None
+        callback_output: CallbackOutcome | None = None
 
         # Listen for WaitForTaskToken signals if an endpoint is provided.
         if callback_endpoint is not None:
@@ -134,7 +135,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
             #       an exception in this thread will invalidate env, and therefore the worker thread.
             #       hence why here there are no explicit stopping logic for thread_wait_for_task_token.
 
-        sync_result: Optional[Any] = None
+        sync_result: Any | None = None
         while env.is_running():
             sync_result = sync_resolver()
             if callback_output or sync_result:
@@ -154,7 +155,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         task_output = env.stack.pop()
 
         # Initialise the waitForTaskToken Callback endpoint for this task if supported.
-        callback_endpoint: Optional[CallbackEndpoint] = None
+        callback_endpoint: CallbackEndpoint | None = None
         if ResourceCondition.WaitForTaskToken in self._supported_integration_patterns:
             callback_id = env.states.context_object.context_object_data["Task"]["Token"]
             callback_endpoint = env.callback_pool_manager.get(callback_id)
@@ -164,7 +165,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         timeout_seconds = env.stack.pop()
 
         # Setup resources for heartbeat workloads if necessary.
-        heartbeat_endpoint: Optional[HeartbeatEndpoint] = None
+        heartbeat_endpoint: HeartbeatEndpoint | None = None
         if self.heartbeat:
             self.heartbeat.eval(env=env)
             heartbeat_seconds = env.stack.pop()
@@ -240,7 +241,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         self,
         timeout_seconds: int,
         callback_endpoint: CallbackEndpoint,
-    ) -> Optional[CallbackOutcome]:
+    ) -> CallbackOutcome | None:
         # Awaits a callback notification and returns the outcome received.
         # If the operation times out or is interrupted it returns None.
 
@@ -249,7 +250,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         # discarded by the main process.
         # Note: although this is the same timeout value, this can only decay strictly after the first timeout
         #       started as it is invoked strictly later.
-        outcome: Optional[CallbackOutcome] = callback_endpoint.wait(timeout=timeout_seconds)
+        outcome: CallbackOutcome | None = callback_endpoint.wait(timeout=timeout_seconds)
         return outcome
 
     def _wait_for_task_token_heartbeat(  # noqa
@@ -257,7 +258,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         env: Environment,
         callback_endpoint: CallbackEndpoint,
         heartbeat_endpoint: HeartbeatEndpoint,
-    ) -> Optional[CallbackOutcome]:
+    ) -> CallbackOutcome | None:
         outcome = None
         while (
             env.is_running()
@@ -285,7 +286,7 @@ class StateTaskServiceCallback(StateTaskService, abc.ABC):
         self, env: Environment, ex: CallbackOutcomeFailureError
     ) -> FailureEvent:
         callback_outcome_failure: CallbackOutcomeFailure = ex.callback_outcome_failure
-        error: Optional[str] = callback_outcome_failure.error
+        error: str | None = callback_outcome_failure.error
         return FailureEvent(
             env=env,
             error_name=CustomErrorName(error_name=error),

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

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from botocore.exceptions import ClientError
 
@@ -76,7 +76,7 @@ _SUPPORTED_API_PARAM_BINDINGS: Final[dict[str, set[str]]] = {
 
 
 class StateTaskServiceDynamoDB(StateTaskService):
-    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())
 
     @staticmethod

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

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Final, Optional
+from collections.abc import Callable
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.credentials import (
     StateCredentials,
@@ -42,7 +43,7 @@ class StateTaskServiceEcs(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 _before_eval_execution(
@@ -102,7 +103,7 @@ class StateTaskServiceEcs(StateTaskServiceCallback):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         ecs_client = boto_client_for(
             service="ecs",
             region=resource_runtime_part.region,
@@ -112,7 +113,7 @@ class StateTaskServiceEcs(StateTaskServiceCallback):
         task_arn: str = submission_output["Tasks"][0]["TaskArn"]
         cluster_arn: str = submission_output["Tasks"][0]["ClusterArn"]
 
-        def _sync_resolver() -> Optional[dict]:
+        def _sync_resolver() -> dict | None:
             describe_tasks_output = ecs_client.describe_tasks(cluster=cluster_arn, tasks=[task_arn])
             last_status: str = describe_tasks_output["tasks"][0]["lastStatus"]
 

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

@@ -1,5 +1,5 @@
 import json
-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.custom_error_name import (
@@ -33,9 +33,9 @@ _SUPPORTED_API_PARAM_BINDINGS: Final[dict[str, set[str]]] = {"putevents": {"Entr
 
 
 class SfnFailedEntryCountException(RuntimeError):
-    cause: Final[Optional[dict]]
+    cause: Final[dict | None]
 
-    def __init__(self, cause: Optional[dict]):
+    def __init__(self, cause: dict | None):
         super().__init__(json.dumps(cause))
         self.cause = cause
 
@@ -44,7 +44,7 @@ class StateTaskServiceEvents(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:

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

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Final, Optional
+from collections.abc import Callable
+from typing import Any, Final
 
 import boto3
 from botocore.exceptions import ClientError
@@ -73,7 +74,7 @@ _API_ACTION_HANDLER_TYPE = Callable[
 ]
 # The type of (sync)handler builder function for StateTaskServiceGlue objects.
 _API_ACTION_HANDLER_BUILDER_TYPE = Callable[
-    [Environment, ResourceRuntimePart, dict, StateCredentials], Callable[[], Optional[Any]]
+    [Environment, ResourceRuntimePart, dict, StateCredentials], Callable[[], Any | None]
 ]
 
 
@@ -81,7 +82,7 @@ class StateTaskServiceGlue(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 _get_api_action_handler(self) -> _API_ACTION_HANDLER_TYPE:
@@ -174,7 +175,7 @@ class StateTaskServiceGlue(StateTaskServiceCallback):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         # Poll the job run state from glue, using GetJobRun until the job has terminated. Hence, append the output
         # of GetJobRun to the state.
 
@@ -188,7 +189,7 @@ class StateTaskServiceGlue(StateTaskServiceCallback):
             resource_runtime_part=resource_runtime_part, state_credentials=state_credentials
         )
 
-        def _sync_resolver() -> Optional[Any]:
+        def _sync_resolver() -> Any | None:
             # Sample GetJobRun until completion.
             get_job_run_response: dict = glue_client.get_job_run(JobName=job_name, RunId=job_run_id)
             job_run: dict = get_job_run_response["JobRun"]
@@ -232,7 +233,7 @@ class StateTaskServiceGlue(StateTaskServiceCallback):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         sync_resolver_builder = self._get_api_action_sync_builder_handler()
         sync_resolver = sync_resolver_builder(
             env, resource_runtime_part, normalised_parameters, state_credentials

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

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import Final, Optional
+from typing import Final
 
 from botocore.exceptions import ClientError
 
@@ -50,7 +50,7 @@ class StateTaskServiceLambda(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())
 
     @staticmethod
@@ -105,8 +105,8 @@ class StateTaskServiceLambda(StateTaskServiceCallback):
     def _normalise_parameters(
         self,
         parameters: dict,
-        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:
         # Run Payload value casting before normalisation.
         if "Payload" in parameters:

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

@@ -1,5 +1,6 @@
 import json
-from typing import Any, Callable, Final, Optional
+from collections.abc import Callable
+from typing import Any, Final
 
 from botocore.exceptions import ClientError
 
@@ -52,7 +53,7 @@ class StateTaskServiceSfn(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:
@@ -91,8 +92,8 @@ class StateTaskServiceSfn(StateTaskServiceCallback):
     def _normalise_parameters(
         self,
         parameters: dict,
-        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:
         if service_action_name is None:
             if self._get_boto_service_action() == "start_execution":
@@ -115,7 +116,7 @@ class StateTaskServiceSfn(StateTaskServiceCallback):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         sfn_client = boto_client_for(
             service="stepfunctions",
             region=resource_runtime_part.region,
@@ -124,7 +125,7 @@ class StateTaskServiceSfn(StateTaskServiceCallback):
         submission_output: dict = env.stack.pop()
         execution_arn: str = submission_output["ExecutionArn"]
 
-        def _sync_resolver() -> Optional[Any]:
+        def _sync_resolver() -> Any | None:
             describe_execution_output = sfn_client.describe_execution(executionArn=execution_arn)
             describe_execution_output: DescribeExecutionOutput = select_from_typed_dict(
                 DescribeExecutionOutput, describe_execution_output
@@ -176,7 +177,7 @@ class StateTaskServiceSfn(StateTaskServiceCallback):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         sfn_client = boto_client_for(
             region=resource_runtime_part.region,
             service="stepfunctions",
@@ -185,7 +186,7 @@ class StateTaskServiceSfn(StateTaskServiceCallback):
         submission_output: dict = env.stack.pop()
         execution_arn: str = submission_output["ExecutionArn"]
 
-        def _sync2_resolver() -> Optional[Any]:
+        def _sync2_resolver() -> Any | None:
             describe_execution_output = sfn_client.describe_execution(executionArn=execution_arn)
             describe_execution_output: DescribeExecutionOutput = select_from_typed_dict(
                 DescribeExecutionOutput, describe_execution_output

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

@@ -1,4 +1,4 @@
-from typing import Final, Optional
+from typing import Final
 
 from botocore.exceptions import ClientError
 
@@ -46,7 +46,7 @@ class StateTaskServiceSns(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:

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,17 +31,17 @@ 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__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.TaskStateEntered,
             state_exited_event_type=HistoryEventType.TaskStateExited,
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateTask, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.resource = state_props.get(Resource)
         self.parargs = state_props.get(Parargs)
         self.credentials = state_props.get(Credentials)
@@ -51,7 +51,7 @@ class StateTask(ExecutionState, abc.ABC):
 
     def _eval_parameters(self, env: Environment) -> dict:
         # Eval raw parameters.
-        parameters = dict()
+        parameters = {}
         if self.parargs is not None:
             self.parargs.eval(env=env)
             parameters = env.stack.pop()

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,11 +20,11 @@ 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)
+        super().from_state_props(state_props)
         self.cause = state_props.get(CauseDecl)
         self.error = state_props.get(ErrorDecl)
 

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,
 )
@@ -13,7 +11,7 @@ from localstack.services.stepfunctions.asl.eval.environment import Environment
 
 class StatePass(CommonStateField):
     def __init__(self):
-        super(StatePass, self).__init__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.PassStateEntered,
             state_exited_event_type=HistoryEventType.PassStateExited,
         )
@@ -21,20 +19,20 @@ 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)
+        super().from_state_props(state_props)
         self.result = state_props.get(Result)
         self.result_path = state_props.get(ResultPath) or ResultPath(
             result_path_src=ResultPath.DEFAULT_PATH

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

@@ -17,7 +17,7 @@ class StateSucceed(CommonStateField):
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateSucceed, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         # TODO: assert all other fields are undefined?
 
         # No Next or End field: Succeed states are terminal states.

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

@@ -19,7 +19,7 @@ class StateWait(CommonStateField):
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateWait, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.wait_function = state_props.get(
             typ=WaitFunction,
             raise_on_missing=ValueError(f"Undefined WaitFunction for StateWait: '{self}'."),

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)