localstack-core 4.7.1.dev22__py3-none-any.whl → 4.7.1.dev24__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()
@@ -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,
@@ -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,
@@ -144,8 +144,8 @@ 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(
@@ -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/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:
@@ -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:
@@ -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:
@@ -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

localstack/services/stepfunctions/quotas.py

@@ -1,12 +1,11 @@
-import json
-from typing import Final, Union
+from typing import Any, Final
 
 from localstack.services.stepfunctions.asl.utils.encoding import to_json_str
 
 MAX_STATE_SIZE_UTF8_BYTES: Final[int] = 256 * 1024  # 256 KB of data as a UTF-8 encoded string.
 
 
-def is_within_size_quota(value: Union[str, json]) -> bool:
+def is_within_size_quota(value: str | Any) -> bool:
     item_str = value if isinstance(value, str) else to_json_str(value)
     item_bytes = item_str.encode("utf-8")
     len_item_bytes = len(item_bytes)

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_activity.py

@@ -2,7 +2,7 @@
 from __future__ import annotations
 
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -14,14 +14,14 @@ from localstack.services.cloudformation.resource_provider import (
 
 
 class StepFunctionsActivityProperties(TypedDict):
-    Name: Optional[str]
-    Arn: Optional[str]
-    Tags: Optional[list[TagsEntry]]
+    Name: str | None
+    Arn: str | None
+    Tags: list[TagsEntry] | None
 
 
 class TagsEntry(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_activity_plugin.py

@@ -1,5 +1,3 @@
-from typing import Optional, Type
-
 from localstack.services.cloudformation.resource_provider import (
     CloudFormationResourceProviderPlugin,
     ResourceProvider,
@@ -10,7 +8,7 @@ class StepFunctionsActivityProviderPlugin(CloudFormationResourceProviderPlugin):
     name = "AWS::StepFunctions::Activity"
 
     def __init__(self):
-        self.factory: Optional[Type[ResourceProvider]] = None
+        self.factory: type[ResourceProvider] | None = None
 
     def load(self):
         from localstack.services.stepfunctions.resource_providers.aws_stepfunctions_activity import (

localstack/services/stepfunctions/resource_providers/aws_stepfunctions_statemachine.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 import json
 import re
 from pathlib import Path
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 import localstack.services.cloudformation.provider_utils as util
 from localstack.services.cloudformation.resource_provider import (
@@ -18,48 +18,48 @@ from localstack.utils.strings import to_str
 
 
 class StepFunctionsStateMachineProperties(TypedDict):
-    RoleArn: Optional[str]
-    Arn: Optional[str]
-    Definition: Optional[dict]
-    DefinitionS3Location: Optional[S3Location]
-    DefinitionString: Optional[str]
-    DefinitionSubstitutions: Optional[dict]
-    LoggingConfiguration: Optional[LoggingConfiguration]
-    Name: Optional[str]
-    StateMachineName: Optional[str]
-    StateMachineRevisionId: Optional[str]
-    StateMachineType: Optional[str]
-    Tags: Optional[list[TagsEntry]]
-    TracingConfiguration: Optional[TracingConfiguration]
+    RoleArn: str | None
+    Arn: str | None
+    Definition: dict | None
+    DefinitionS3Location: S3Location | None
+    DefinitionString: str | None
+    DefinitionSubstitutions: dict | None
+    LoggingConfiguration: LoggingConfiguration | None
+    Name: str | None
+    StateMachineName: str | None
+    StateMachineRevisionId: str | None
+    StateMachineType: str | None
+    Tags: list[TagsEntry] | None
+    TracingConfiguration: TracingConfiguration | None
 
 
 class CloudWatchLogsLogGroup(TypedDict):
-    LogGroupArn: Optional[str]
+    LogGroupArn: str | None
 
 
 class LogDestination(TypedDict):
-    CloudWatchLogsLogGroup: Optional[CloudWatchLogsLogGroup]
+    CloudWatchLogsLogGroup: CloudWatchLogsLogGroup | None
 
 
 class LoggingConfiguration(TypedDict):
-    Destinations: Optional[list[LogDestination]]
-    IncludeExecutionData: Optional[bool]
-    Level: Optional[str]
+    Destinations: list[LogDestination] | None
+    IncludeExecutionData: bool | None
+    Level: str | None
 
 
 class TracingConfiguration(TypedDict):
-    Enabled: Optional[bool]
+    Enabled: bool | None
 
 
 class S3Location(TypedDict):
-    Bucket: Optional[str]
-    Key: Optional[str]
-    Version: Optional[str]
+    Bucket: str | None
+    Key: str | None
+    Version: str | None
 
 
 class TagsEntry(TypedDict):
-    Key: Optional[str]
-    Value: Optional[str]
+    Key: str | None
+    Value: str | None
 
 
 REPEATED_INVOCATION = "repeated_invocation"