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_map/iteration/iterator/distributed_iterator_worker.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from localstack.services.stepfunctions.asl.component.common.error_name.failure_event import (
     FailureEventException,
 )
@@ -35,9 +33,9 @@ class DistributedIteratorWorker(InlineIteratorWorker):
         work_name: str,
         job_pool: JobPool,
         env: Environment,
-        parameters: Optional[Parameters],
+        parameters: Parameters | None,
         map_run_record: MapRunRecord,
-        item_selector: Optional[ItemSelector],
+        item_selector: ItemSelector | None,
     ):
         super().__init__(
             work_name=work_name,
@@ -99,7 +97,7 @@ class DistributedIteratorWorker(InlineIteratorWorker):
             self._map_run_record.item_counter.running.offset(-1)
             job.job_output = job_output
 
-    def _eval_pool(self, job: Optional[Job], worker_frame: Environment) -> None:
+    def _eval_pool(self, job: Job | None, worker_frame: Environment) -> None:
         # Note: the frame has to be closed before the job, to ensure the owner environment is correctly updated
         #  before the evaluation continues; map states await for job termination not workers termination.
         if job is None:

localstack/services/stepfunctions/asl/component/state/state_execution/state_map/iteration/iterator/inline_iterator.py

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import logging
-from typing import Optional
 
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.iteration.inline_iteration_component import (
     InlineIterationComponent,
@@ -26,7 +25,7 @@ class InlineIteratorEvalInput(InlineIterationComponentEvalInput):
 
 
 class InlineIterator(InlineIterationComponent):
-    _eval_input: Optional[InlineIteratorEvalInput]
+    _eval_input: InlineIteratorEvalInput | None
 
     def _create_worker(
         self, env: Environment, eval_input: InlineIteratorEvalInput, job_pool: JobPool

localstack/services/stepfunctions/asl/component/state/state_execution/state_map/iteration/iterator/inline_iterator_worker.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Final, Optional
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.common.parargs import Parameters
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.item_selector import (
@@ -17,16 +17,16 @@ LOG = logging.getLogger(__name__)
 
 
 class InlineIteratorWorker(IterationWorker):
-    _parameters: Final[Optional[Parameters]]
-    _item_selector: Final[Optional[ItemSelector]]
+    _parameters: Final[Parameters | None]
+    _item_selector: Final[ItemSelector | None]
 
     def __init__(
         self,
         work_name: str,
         job_pool: JobPool,
         env: Environment,
-        item_selector: Optional[ItemSelector],
-        parameters: Optional[Parameters],
+        item_selector: ItemSelector | None,
+        parameters: Parameters | None,
     ):
         super().__init__(work_name=work_name, job_pool=job_pool, env=env)
         self._item_selector = item_selector

localstack/services/stepfunctions/asl/component/state/state_execution/state_map/iteration/job.py

@@ -1,7 +1,7 @@
 import copy
 import logging
 import threading
-from typing import Any, Final, Optional
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.component.program.program import Program
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
@@ -12,10 +12,10 @@ LOG = logging.getLogger(__name__)
 class Job:
     job_index: Final[int]
     job_program: Final[Program]
-    job_input: Final[Optional[Any]]
-    job_output: Optional[Any]
+    job_input: Final[Any | None]
+    job_output: Any | None
 
-    def __init__(self, job_index: int, job_program: Program, job_input: Optional[Any]):
+    def __init__(self, job_index: int, job_program: Program, job_input: Any | None):
         self.job_index = job_index
         self.job_program = job_program
         self.job_input = job_input
@@ -24,9 +24,9 @@ class Job:
 
 class JobClosed:
     job_index: Final[int]
-    job_output: Optional[Any]
+    job_output: Any | None
 
-    def __init__(self, job_index: int, job_output: Optional[Any]):
+    def __init__(self, job_index: int, job_output: Any | None):
         self.job_index = job_index
         self.job_output = job_output
 
@@ -37,7 +37,7 @@ class JobClosed:
 class JobPool:
     _mutex: Final[threading.Lock]
     _termination_event: Final[threading.Event]
-    _worker_exception: Optional[Exception]
+    _worker_exception: Exception | None
 
     _jobs_number: Final[int]
     _open_jobs: Final[list[Job]]
@@ -56,7 +56,7 @@ class JobPool:
         self._open_jobs.reverse()
         self._closed_jobs = set()
 
-    def next_job(self) -> Optional[Any]:
+    def next_job(self) -> Any | None:
         with self._mutex:
             if self._worker_exception is not None:
                 return None
@@ -72,7 +72,7 @@ class JobPool:
         if self._is_terminated():
             self._termination_event.set()
 
-    def get_worker_exception(self) -> Optional[Exception]:
+    def get_worker_exception(self) -> Exception | None:
         return self._worker_exception
 
     def close_job(self, job: Job) -> None:

localstack/services/stepfunctions/asl/component/state/state_execution/state_map/result_writer/resource_eval/resource_eval_s3.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 import json
-from typing import Callable, Final
+from collections.abc import Callable
+from typing import Final
 
 from localstack.services.stepfunctions.asl.component.state.state_execution.state_map.result_writer.resource_eval.resource_eval import (
     ResourceEval,

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

@@ -1,5 +1,4 @@
 import copy
-from typing import Optional
 
 from localstack.aws.api.stepfunctions import (
     EvaluationFailedEventDetails,
@@ -99,30 +98,30 @@ from localstack.services.stepfunctions.asl.eval.event.event_detail import EventD
 
 
 class StateMap(ExecutionState):
-    items: Optional[Items]
-    items_path: Optional[ItemsPath]
+    items: Items | None
+    items_path: ItemsPath | None
     iteration_component: IterationComponent
-    item_reader: Optional[ItemReader]
-    item_selector: Optional[ItemSelector]
-    parameters: Optional[Parameters]
+    item_reader: ItemReader | None
+    item_selector: ItemSelector | None
+    parameters: Parameters | None
     max_concurrency_decl: MaxConcurrencyDecl
     tolerated_failure_count_decl: ToleratedFailureCountDecl
     tolerated_failure_percentage_decl: ToleratedFailurePercentage
-    result_path: Optional[ResultPath]
+    result_path: ResultPath | None
     result_selector: ResultSelector
-    retry: Optional[RetryDecl]
-    catch: Optional[CatchDecl]
-    label: Optional[Label]
-    result_writer: Optional[ResultWriter]
+    retry: RetryDecl | None
+    catch: CatchDecl | None
+    label: Label | None
+    result_writer: ResultWriter | None
 
     def __init__(self):
-        super(StateMap, self).__init__(
+        super().__init__(
             state_entered_event_type=HistoryEventType.MapStateEntered,
             state_exited_event_type=HistoryEventType.MapStateExited,
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateMap, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         if self._is_language_query_jsonpath():
             self.items = None
             self.items_path = state_props.get(ItemsPath) or ItemsPath(

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

@@ -1,7 +1,7 @@
 import abc
 import logging
 import threading
-from typing import Final, Optional
+from typing import Final
 
 from localstack.aws.api.stepfunctions import Timestamp
 from localstack.services.stepfunctions.asl.component.program.program import Program
@@ -18,7 +18,7 @@ class BranchWorker:
 
     _branch_worker_comm: Final[BranchWorkerComm]
     _program: Final[Program]
-    _worker_thread: Optional[threading.Thread]
+    _worker_thread: threading.Thread | None
     env: Final[Environment]
 
     def __init__(self, branch_worker_comm: BranchWorkerComm, program: Program, env: Environment):
@@ -43,7 +43,7 @@ class BranchWorker:
         TMP_THREADS.append(self._worker_thread)
         self._worker_thread.start()
 
-    def stop(self, stop_date: Timestamp, cause: Optional[str], error: Optional[str]) -> None:
+    def stop(self, stop_date: Timestamp, cause: str | None, error: str | None) -> None:
         env = self.env
         if env:
             try:

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()
@@ -42,7 +42,7 @@ class BranchWorkerPool(BranchWorker.BranchWorkerComm):
             end_program_state: ProgramState = env.program_state()
             if isinstance(end_program_state, ProgramError):
                 self._terminated_with_error = select_from_typed_dict(
-                    typed_dict=ExecutionFailedEventDetails, obj=end_program_state.error or dict()
+                    typed_dict=ExecutionFailedEventDetails, obj=end_program_state.error or {}
                 )
                 self._termination_event.set()
             else:
@@ -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
 
 
@@ -67,7 +67,7 @@ class BranchesDecl(EvalComponent):
 
         branch_worker_pool = BranchWorkerPool(workers_num=len(self.programs))
 
-        branch_workers: list[BranchWorker] = list()
+        branch_workers: list[BranchWorker] = []
         for program in self.programs:
             # Environment frame for this sub process.
             env_frame: Environment = env.open_inner_frame()
@@ -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:
@@ -103,7 +103,7 @@ class BranchesDecl(EvalComponent):
             )
 
         # Collect the results and return.
-        result_list = list()
+        result_list = []
 
         for worker in branch_workers:
             env_frame = worker.env

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__(
@@ -34,7 +33,7 @@ class StateParallel(ExecutionState):
         )
 
     def from_state_props(self, state_props: StateProps) -> None:
-        super(StateParallel, self).from_state_props(state_props)
+        super().from_state_props(state_props)
         self.branches = state_props.get(
             typ=BranchesDecl,
             raise_on_missing=ValueError(f"Missing Branches definition in props '{state_props}'."),

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,12 +85,12 @@ 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
 
     if payload is None:
-        str_value = to_json_str(dict())
+        str_value = to_json_str({})
     elif isinstance(payload, str):
         try:
             json.loads(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,8 +167,8 @@ class StateTaskServiceApiGateway(StateTaskServiceCallback):
         return query_str
 
     @staticmethod
-    def _headers_of(parameters: TaskParameters) -> Optional[dict]:
-        headers = parameters.get("Headers", dict())
+    def _headers_of(parameters: TaskParameters) -> dict | None:
+        headers = parameters.get("Headers", {})
         if headers:
             for key in headers.keys():
                 # TODO: the following check takes place at parse time.
@@ -239,8 +239,8 @@ class StateTaskServiceApiGateway(StateTaskServiceCallback):
             response_body = response.json()
         except JSONDecodeError:
             response_body = response.text
-            if response_body == json.dumps(dict()):
-                response_body = dict()
+            if response_body == json.dumps({}):
+                response_body = {}
 
         # since we are not using a case-insensitive dict, and we want to remove a header, for server
         # compatibility we should consider both casing variants

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

@@ -132,7 +132,7 @@ class StateTaskServiceAwsSdk(StateTaskServiceCallback):
             region=resource_runtime_part.region,
             state_credentials=state_credentials,
         )
-        response = getattr(api_client, api_action)(**normalised_parameters) or dict()
+        response = getattr(api_client, api_action)(**normalised_parameters) or {}
         if response:
             response.pop("ResponseMetadata", None)
         env.stack.append(response)

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
@@ -70,12 +71,12 @@ class StateTaskServiceBatch(StateTaskServiceCallback):
         # Attaches to the ContainerOverrides environment variables the AWS managed flags.
         container_overrides = parameters.get("ContainerOverrides")
         if container_overrides is None:
-            container_overrides = dict()
+            container_overrides = {}
             parameters["ContainerOverrides"] = container_overrides
 
         environment = container_overrides.get("Environment")
         if environment is None:
-            environment = list()
+            environment = []
             container_overrides["Environment"] = environment
 
         environment.append(
@@ -117,7 +118,7 @@ class StateTaskServiceBatch(StateTaskServiceCallback):
                     "Proxy: null",
                 ]
             )
-            cause = f"Error executing request, Exception : {error_message}, RequestId: {request_id} ({response_details})"
+            cause = f"{error_message} ({response_details})"
             return FailureEvent(
                 env=env,
                 error_name=CustomErrorName(error_name),
@@ -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: