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

localstack/services/stepfunctions/asl/component/state/state_execution/state_parallel/branches_decl.py

@@ -1,6 +1,6 @@
 import datetime
 import threading
-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.custom_error_name import (
@@ -26,7 +26,7 @@ class BranchWorkerPool(BranchWorker.BranchWorkerComm):
     _termination_event: Final[threading.Event]
     _active_workers_num: int
 
-    _terminated_with_error: Optional[ExecutionFailedEventDetails]
+    _terminated_with_error: ExecutionFailedEventDetails | None
 
     def __init__(self, workers_num: int):
         self._mutex = threading.Lock()
@@ -53,7 +53,7 @@ class BranchWorkerPool(BranchWorker.BranchWorkerComm):
     def wait(self):
         self._termination_event.wait()
 
-    def get_exit_event_details(self) -> Optional[ExecutionFailedEventDetails]:
+    def get_exit_event_details(self) -> ExecutionFailedEventDetails | None:
         return self._terminated_with_error
 
 
@@ -84,7 +84,7 @@ class BranchesDecl(EvalComponent):
         branch_worker_pool.wait()
 
         # Propagate exception if parallel task failed.
-        exit_event_details: Optional[ExecutionFailedEventDetails] = (
+        exit_event_details: ExecutionFailedEventDetails | None = (
             branch_worker_pool.get_exit_event_details()
         )
         if exit_event_details is not None:

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

@@ -1,5 +1,4 @@
 import copy
-from typing import Optional
 
 from localstack.aws.api.stepfunctions import HistoryEventType
 from localstack.services.stepfunctions.asl.component.common.catch.catch_outcome import CatchOutcome
@@ -25,7 +24,7 @@ class StateParallel(ExecutionState):
     # machine object must have fields named States and StartAt, whose meanings are exactly
     # like those in the top level of a state machine.
     branches: BranchesDecl
-    parargs: Optional[Parargs]
+    parargs: Parargs | None
 
     def __init__(self):
         super().__init__(

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

@@ -1,6 +1,6 @@
 import json
 from json import JSONDecodeError
-from typing import IO, Any, Final, Optional, Union
+from typing import IO, Any, Final
 
 from localstack.aws.api.lambda_ import InvocationResponse
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_task.credentials import (
@@ -18,15 +18,15 @@ from localstack.utils.strings import to_bytes
 
 
 class LambdaFunctionErrorException(Exception):
-    function_error: Final[Optional[str]]
+    function_error: Final[str | None]
     payload: Final[str]
 
-    def __init__(self, function_error: Optional[str], payload: str):
+    def __init__(self, function_error: str | None, payload: str):
         self.function_error = function_error
         self.payload = payload
 
 
-def _from_payload(payload_streaming_body: IO[bytes]) -> Union[json, str]:
+def _from_payload(payload_streaming_body: IO[bytes]) -> Any | str:
     """
     This method extracts the lambda payload. The payload may be a string or a JSON stringified object.
     In the first case, this function converts the output into a UTF-8 string, otherwise it parses the
@@ -75,7 +75,7 @@ def execute_lambda_function_integration(
             parameters=parameters, region=region, state_credentials=state_credentials
         )
 
-    function_error: Optional[str] = invocation_response.get("FunctionError")
+    function_error: str | None = invocation_response.get("FunctionError")
     if function_error:
         payload_json = invocation_response["Payload"]
         payload_str = json.dumps(payload_json, separators=(",", ":"))
@@ -85,7 +85,7 @@ def execute_lambda_function_integration(
     env.stack.append(response)
 
 
-def to_payload_type(payload: Any) -> Optional[bytes]:
+def to_payload_type(payload: Any) -> bytes | None:
     if isinstance(payload, bytes):
         return payload
 

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

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import abc
 from itertools import takewhile
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.eval_component import EvalComponent
 from localstack.services.stepfunctions.asl.eval.environment import Environment
@@ -33,7 +33,7 @@ class ResourceARN:
         account: str,
         task_type: str,
         name: str,
-        option: Optional[str],
+        option: str | None,
     ):
         self.arn = arn
         self.partition = partition
@@ -137,7 +137,7 @@ class ServiceResource(Resource):
     service_name: Final[str]
     api_name: Final[str]
     api_action: Final[str]
-    condition: Final[Optional[str]]
+    condition: Final[str | None]
 
     def __init__(self, resource_arn: ResourceARN):
         super().__init__(resource_arn=resource_arn)

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

@@ -4,7 +4,7 @@ import abc
 import copy
 import json
 import logging
-from typing import Any, Final, Optional, Union
+from typing import Any, Final
 
 from botocore.model import ListShape, OperationModel, Shape, StringShape, StructureShape
 from botocore.response import StreamingBody
@@ -147,8 +147,8 @@ class StateTaskService(StateTask, abc.ABC):
         parameters_bind_keys: list[str] = list(parameters.keys())
         for parameter_key in parameters_bind_keys:
             norm_parameter_key = camel_to_snake_case(parameter_key)
-            norm_member_bind: Optional[tuple[str, Optional[StructureShape]]] = (
-                norm_member_binds.get(norm_parameter_key)
+            norm_member_bind: tuple[str, StructureShape | None] | None = norm_member_binds.get(
+                norm_parameter_key
             )
             if norm_member_bind is not None:
                 norm_member_bind_key, norm_member_bind_shape = norm_member_bind
@@ -203,19 +203,19 @@ class StateTaskService(StateTask, abc.ABC):
 
                 response[norm_response_key] = response_value
 
-    def _get_boto_service_name(self, boto_service_name: Optional[str] = None) -> str:
+    def _get_boto_service_name(self, boto_service_name: str | None = None) -> str:
         api_name = boto_service_name or self.resource.api_name
         return self._SERVICE_NAME_SFN_TO_BOTO_OVERRIDES.get(api_name, api_name)
 
-    def _get_boto_service_action(self, service_action_name: Optional[str] = None) -> str:
+    def _get_boto_service_action(self, service_action_name: str | None = None) -> str:
         api_action = service_action_name or self.resource.api_action
         return camel_to_snake_case(api_action)
 
     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:
         boto_service_name = self._get_boto_service_name(boto_service_name=boto_service_name)
         service_action_name = self._get_boto_service_action(service_action_name=service_action_name)
@@ -228,8 +228,8 @@ class StateTaskService(StateTask, abc.ABC):
     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:
         boto_service_name = self._get_boto_service_name(boto_service_name=boto_service_name)
         service_action_name = self._get_boto_service_action(service_action_name=service_action_name)
@@ -239,7 +239,7 @@ class StateTaskService(StateTask, abc.ABC):
         if output_shape is not None:
             self._from_boto_response(response, output_shape)  # noqa
 
-    def _verify_size_quota(self, env: Environment, value: Union[str, json]) -> None:
+    def _verify_size_quota(self, env: Environment, value: str | json) -> None:
         is_within: bool = is_within_size_quota(value)
         if is_within:
             return

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

@@ -4,7 +4,7 @@ import http
 import json
 import logging
 from json import JSONDecodeError
-from typing import Any, Final, Optional, TypedDict
+from typing import Any, Final, TypedDict
 from urllib.parse import urlencode, urljoin, urlparse
 
 import requests
@@ -76,13 +76,13 @@ class AuthType(str):
 class TaskParameters(TypedDict):
     ApiEndpoint: ApiEndpoint
     Method: Method
-    Headers: Optional[Headers]
-    Stage: Optional[Stage]
-    Path: Optional[Path]
-    QueryParameters: Optional[QueryParameters]
-    RequestBody: Optional[RequestBody]
-    AllowNullValues: Optional[AllowNullValues]
-    AuthType: Optional[AuthType]
+    Headers: Headers | None
+    Stage: Stage | None
+    Path: Path | None
+    QueryParameters: QueryParameters | None
+    RequestBody: RequestBody | None
+    AllowNullValues: AllowNullValues | None
+    AuthType: AuthType | None
 
 
 class InvokeOutput(TypedDict):
@@ -131,14 +131,14 @@ class StateTaskServiceApiGateway(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 self._SUPPORTED_API_PARAM_BINDINGS.get(self.resource.api_action.lower())
 
     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:
         # ApiGateway does not support botocore request relay.
         pass
@@ -146,14 +146,14 @@ class StateTaskServiceApiGateway(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:
         # ApiGateway does not support botocore request relay.
         pass
 
     @staticmethod
-    def _query_parameters_of(parameters: TaskParameters) -> Optional[str]:
+    def _query_parameters_of(parameters: TaskParameters) -> str | None:
         query_str = None
         query_parameters = parameters.get("QueryParameters")
         # TODO: add support for AllowNullValues.
@@ -167,7 +167,7 @@ class StateTaskServiceApiGateway(StateTaskServiceCallback):
         return query_str
 
     @staticmethod
-    def _headers_of(parameters: TaskParameters) -> Optional[dict]:
+    def _headers_of(parameters: TaskParameters) -> dict | None:
         headers = parameters.get("Headers", dict())
         if headers:
             for key in headers.keys():

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

@@ -1,4 +1,5 @@
-from typing import Any, Callable, Final, Optional
+from collections.abc import Callable
+from typing import Any, Final
 
 from botocore.exceptions import ClientError
 from moto.batch.utils import JobStatus
@@ -62,7 +63,7 @@ class StateTaskServiceBatch(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
@@ -139,7 +140,7 @@ class StateTaskServiceBatch(StateTaskServiceCallback):
         resource_runtime_part: ResourceRuntimePart,
         normalised_parameters: dict,
         state_credentials: StateCredentials,
-    ) -> Callable[[], Optional[Any]]:
+    ) -> Callable[[], Any | None]:
         batch_client = boto_client_for(
             service="batch",
             region=resource_runtime_part.region,
@@ -148,7 +149,7 @@ class StateTaskServiceBatch(StateTaskServiceCallback):
         submission_output: dict = env.stack.pop()
         job_id = submission_output["JobId"]
 
-        def _sync_resolver() -> Optional[dict]:
+        def _sync_resolver() -> dict | None:
             describe_jobs_response = batch_client.describe_jobs(jobs=[job_id])
             describe_jobs = describe_jobs_response["jobs"]
             if describe_jobs:

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: