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

localstack/utils/batch_policy.py

@@ -1,6 +1,6 @@
 import copy
 import time
-from typing import Generic, List, Optional, TypeVar, overload
+from typing import Generic, TypeVar, overload
 
 from pydantic import Field
 from pydantic.dataclasses import dataclass
@@ -47,8 +47,8 @@ class Batcher(Generic[T]):
         assert batcher.flush() == ["item1", "item2", "item3", "item4"]
     """
 
-    max_count: Optional[int] = Field(default=None, description="Maximum number of items", ge=0)
-    max_window: Optional[float] = Field(
+    max_count: int | None = Field(default=None, description="Maximum number of items", ge=0)
+    max_window: float | None = Field(
         default=None, description="Maximum time window in seconds", ge=0
     )
 
@@ -76,7 +76,7 @@ class Batcher(Generic[T]):
     def add(self, item: T, *, deep_copy: bool = False) -> BatchPolicyTriggered: ...
 
     @overload
-    def add(self, items: List[T], *, deep_copy: bool = False) -> BatchPolicyTriggered: ...
+    def add(self, items: list[T], *, deep_copy: bool = False) -> BatchPolicyTriggered: ...
 
     def add(self, item_or_items: T | list[T], *, deep_copy: bool = False) -> BatchPolicyTriggered:
         """

localstack/utils/bootstrap.py

@@ -9,8 +9,9 @@ import shlex
 import signal
 import threading
 import time
+from collections.abc import Callable, Iterable
 from functools import wraps
-from typing import Any, Callable, Dict, Iterable, List, Optional, Set, Union
+from typing import Any
 
 from localstack import config, constants
 from localstack.config import (
@@ -156,7 +157,7 @@ def log_duration(name=None, min_ms=500):
     return wrapper
 
 
-def get_docker_image_details(image_name: str = None) -> Dict[str, str]:
+def get_docker_image_details(image_name: str = None) -> dict[str, str]:
     image_name = image_name or get_docker_image_to_start()
     try:
         result = DOCKER_CLIENT.inspect_image(image_name)
@@ -174,7 +175,7 @@ def get_docker_image_details(image_name: str = None) -> Dict[str, str]:
     return result
 
 
-def get_image_environment_variable(env_name: str) -> Optional[str]:
+def get_image_environment_variable(env_name: str) -> str | None:
     image_name = get_docker_image_to_start()
     image_info = DOCKER_CLIENT.inspect_image(image_name)
     image_envs = image_info["Config"]["Env"]
@@ -249,7 +250,7 @@ def setup_logging():
 # --------------
 
 
-def resolve_apis(services: Iterable[str]) -> Set[str]:
+def resolve_apis(services: Iterable[str]) -> set[str]:
     """
     Resolves recursively for the given collection of services (e.g., ["serverless", "cognito"]) the list of actual
     API services that need to be included (e.g., {'dynamodb', 'cloudformation', 'logs', 'kinesis', 'sts',
@@ -289,8 +290,8 @@ def resolve_apis(services: Iterable[str]) -> Set[str]:
     return result
 
 
-@functools.lru_cache()
-def get_enabled_apis() -> Set[str]:
+@functools.lru_cache
+def get_enabled_apis() -> set[str]:
     """
     Returns the list of APIs that are enabled through the combination of the SERVICES variable and
     STRICT_SERVICE_LOADING variable. If the SERVICES variable is empty, then it will return all available services.
@@ -324,8 +325,8 @@ def is_api_enabled(api: str) -> bool:
     return api in get_enabled_apis()
 
 
-@functools.lru_cache()
-def get_preloaded_services() -> Set[str]:
+@functools.lru_cache
+def get_preloaded_services() -> set[str]:
     """
     Returns the list of APIs that are marked to be eager loaded through the combination of SERVICES variable and
     EAGER_SERVICE_LOADING. If the SERVICES variable is empty, then it will return all available services.
@@ -426,15 +427,13 @@ def validate_localstack_config(name: str):
 
     def port_exposed(port):
         for exposed in docker_ports:
-            if re.match(r"^([0-9]+-)?%s(-[0-9]+)?$" % port, exposed):
+            if re.match(rf"^([0-9]+-)?{port}(-[0-9]+)?$", exposed):
                 return True
 
     if not port_exposed(edge_port):
         warns.append(
-            (
-                f"Edge port {edge_port} is not exposed. You may have to add the entry "
-                'to the "ports" section of the docker-compose file.'
-            )
+            f"Edge port {edge_port} is not exposed. You may have to add the entry "
+            'to the "ports" section of the docker-compose file.'
         )
 
     # print warning/info messages
@@ -456,7 +455,7 @@ def get_docker_image_to_start():
 
 def extract_port_flags(user_flags, port_mappings: PortMappings):
     regex = r"-p\s+([0-9]+)(\-([0-9]+))?:([0-9]+)(\-([0-9]+))?"
-    matches = re.match(".*%s" % regex, user_flags)
+    matches = re.match(f".*{regex}", user_flags)
     if matches:
         for match in re.findall(regex, user_flags):
             start = int(match[0])
@@ -545,7 +544,7 @@ class ContainerConfigurators:
 
     @staticmethod
     def gateway_listen(
-        port: Union[int, Iterable[int], HostAndPort, Iterable[HostAndPort]],
+        port: int | Iterable[int] | HostAndPort | Iterable[HostAndPort],
     ):
         """
         Uses the given ports to configure GATEWAY_LISTEN. For instance, ``gateway_listen([4566, 443])`` would
@@ -638,7 +637,7 @@ class ContainerConfigurators:
         return _cfg
 
     @staticmethod
-    def custom_command(cmd: List[str]):
+    def custom_command(cmd: list[str]):
         """
         Overwrites the container command and unsets the default entrypoint.
 
@@ -653,7 +652,7 @@ class ContainerConfigurators:
         return _cfg
 
     @staticmethod
-    def env_vars(env_vars: Dict[str, str]):
+    def env_vars(env_vars: dict[str, str]):
         def _cfg(cfg: ContainerConfiguration):
             cfg.env_vars.update(env_vars)
 
@@ -674,7 +673,7 @@ class ContainerConfigurators:
         return _cfg
 
     @staticmethod
-    def cli_params(params: Dict[str, Any]):
+    def cli_params(params: dict[str, Any]):
         """
         Parse docker CLI parameters and add them to the config. The currently known CLI params are::
 
@@ -808,7 +807,7 @@ def get_gateway_port(container: Container) -> int:
     :param container: the localstack container
     :return: the gateway port reachable from the host
     """
-    candidates: List[int]
+    candidates: list[int]
 
     gateway_listen = container.config.env_vars.get("GATEWAY_LISTEN")
     if gateway_listen:
@@ -1001,7 +1000,7 @@ class RunningContainer:
                     return
                 raise
 
-    def inspect(self) -> Dict[str, Union[Dict, str]]:
+    def inspect(self) -> dict[str, dict | str]:
         return self.container_client.inspect_container(container_name_or_id=self.id)
 
     def attach(self):
@@ -1029,11 +1028,11 @@ class ContainerLogPrinter:
         self.callback = callback
 
         self._closed = threading.Event()
-        self._stream: Optional[CancellableStream] = None
+        self._stream: CancellableStream | None = None
 
     def _can_start_streaming(self):
         if self._closed.is_set():
-            raise IOError("Already stopped")
+            raise OSError("Already stopped")
         if not self.container.running_container:
             return False
         return self.container.running_container.is_running()
@@ -1041,7 +1040,7 @@ class ContainerLogPrinter:
     def run(self):
         try:
             poll_condition(self._can_start_streaming)
-        except IOError:
+        except OSError:
             return
         self._stream = self.container.running_container.stream_logs()
         for line in self._stream:
@@ -1115,8 +1114,8 @@ class LocalstackContainerServer(Server):
 
     def do_run(self):
         if self.is_container_running():
-            raise ContainerExists(
-                'LocalStack container named "%s" is already running' % self.container.name
+            raise ContainerRunning(
+                f'LocalStack container named "{self.container.name}" is already running'
             )
 
         config.dirs.mkdirs()
@@ -1152,12 +1151,19 @@ class ContainerExists(Exception):
     pass
 
 
+class ContainerRunning(Exception):
+    pass
+
+
 def prepare_docker_start():
     # prepare environment for docker start
     container_name = config.MAIN_CONTAINER_NAME
 
     if DOCKER_CLIENT.is_container_running(container_name):
-        raise ContainerExists('LocalStack container named "%s" is already running' % container_name)
+        raise ContainerRunning(f'LocalStack container named "{container_name}" is already running')
+
+    if container_name in DOCKER_CLIENT.get_all_container_names():
+        raise ContainerExists(f'LocalStack container named "{container_name}" already exists')
 
     config.dirs.mkdirs()
 
@@ -1227,7 +1233,7 @@ def prepare_host(console):
     hooks.prepare_host.run()
 
 
-def start_infra_in_docker(console, cli_params: Dict[str, Any] = None):
+def start_infra_in_docker(console, cli_params: dict[str, Any] = None):
     prepare_docker_start()
 
     # create and prepare container
@@ -1302,14 +1308,15 @@ def ensure_container_image(console, container: Container):
         console.log("download complete")
 
 
-def start_infra_in_docker_detached(console, cli_params: Dict[str, Any] = None):
+def start_infra_in_docker_detached(console, cli_params: dict[str, Any] = None):
     """
     An alternative to start_infra_in_docker where the terminal is not blocked by the follow on the logfile.
     """
     console.log("preparing environment")
     try:
         prepare_docker_start()
-    except ContainerExists as e:
+    except ContainerRunning as e:
+        # starting in detached mode is idempotent, return if container is already running
         console.print(str(e))
         return
 
@@ -1331,7 +1338,7 @@ def start_infra_in_docker_detached(console, cli_params: Dict[str, Any] = None):
     console.log("detaching")
 
 
-def wait_container_is_ready(timeout: Optional[float] = None):
+def wait_container_is_ready(timeout: float | None = None):
     """Blocks until the localstack main container is running and the ready marker has been printed."""
     container_name = config.MAIN_CONTAINER_NAME
     started = time.time()

localstack/utils/catalog/catalog.py

@@ -0,0 +1,139 @@
+import logging
+from abc import abstractmethod
+
+from plux import Plugin
+
+from localstack.services.cloudformation.resource_provider import (
+    plugin_manager as cfn_plugin_manager,
+)
+from localstack.utils.catalog.catalog_loader import RemoteCatalogLoader
+from localstack.utils.catalog.common import (
+    AwsServiceOperationsSupportInLatest,
+    AwsServicesSupportInLatest,
+    AwsServiceSupportAtRuntime,
+    CloudFormationResourcesSupportAtRuntime,
+    CloudFormationResourcesSupportInLatest,
+    LocalstackEmulatorType,
+)
+
+ServiceName = str
+ServiceOperations = set[str]
+ProviderName = str
+CfnResourceName = str
+CfnResourceMethodName = str
+AwsServicesSupportStatus = (
+    AwsServiceSupportAtRuntime | AwsServicesSupportInLatest | AwsServiceOperationsSupportInLatest
+)
+CfnResourceSupportStatus = (
+    CloudFormationResourcesSupportInLatest | CloudFormationResourcesSupportAtRuntime
+)
+CfnResourceCatalog = dict[LocalstackEmulatorType, dict[CfnResourceName, set[CfnResourceMethodName]]]
+
+LOG = logging.getLogger(__name__)
+
+
+class CatalogPlugin(Plugin):
+    namespace = "localstack.utils.catalog"
+
+    @staticmethod
+    def _get_cfn_resources_catalog(cloudformation_resources: dict) -> CfnResourceCatalog:
+        cfn_resources_catalog = {}
+        for emulator_type, resources in cloudformation_resources.items():
+            cfn_resources_catalog[emulator_type] = {}
+            for resource_name, resource in resources.items():
+                cfn_resources_catalog[emulator_type][resource_name] = set(resource.methods)
+        return cfn_resources_catalog
+
+    @staticmethod
+    def _get_services_at_runtime() -> set[ServiceName]:
+        from localstack.services.plugins import SERVICE_PLUGINS
+
+        return set(SERVICE_PLUGINS.list_available())
+
+    @staticmethod
+    def _get_cfn_resources_available_at_runtime() -> set[CfnResourceName]:
+        return set(cfn_plugin_manager.list_names())
+
+    @abstractmethod
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        pass
+
+    @abstractmethod
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        pass
+
+
+class AwsCatalogRuntimePlugin(CatalogPlugin):
+    name = "aws-catalog-runtime-only"
+
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        return None
+
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        return None
+
+
+class AwsCatalogRemoteStatePlugin(CatalogPlugin):
+    name = "aws-catalog-remote-state"
+    current_emulator_type: LocalstackEmulatorType = LocalstackEmulatorType.COMMUNITY
+    services_in_latest: dict[ServiceName, dict[LocalstackEmulatorType, ServiceOperations]] = {}
+    services_at_runtime: set[ServiceName] = set()
+    cfn_resources_in_latest: CfnResourceCatalog = {}
+    cfn_resources_at_runtime: set[CfnResourceName] = set()
+
+    def __init__(self, remote_catalog_loader: RemoteCatalogLoader | None = None) -> None:
+        catalog_loader = remote_catalog_loader or RemoteCatalogLoader()
+        remote_catalog = catalog_loader.get_remote_catalog()
+        for service_name, emulators in remote_catalog.services.items():
+            for emulator_type, service_provider in emulators.items():
+                self.services_in_latest.setdefault(service_name, {})[emulator_type] = set(
+                    service_provider.operations
+                )
+
+        self.cfn_resources_in_latest = self._get_cfn_resources_catalog(
+            remote_catalog.cloudformation_resources
+        )
+        self.cfn_resources_at_runtime = self._get_cfn_resources_available_at_runtime()
+        self.services_at_runtime = self._get_services_at_runtime()
+
+    def get_aws_service_status(
+        self, service_name: str, operation_name: str | None = None
+    ) -> AwsServicesSupportStatus | None:
+        if not self.services_in_latest:
+            return None
+        if service_name not in self.services_in_latest:
+            return AwsServicesSupportInLatest.NOT_SUPPORTED
+        if self.current_emulator_type not in self.services_in_latest[service_name]:
+            return AwsServicesSupportInLatest.SUPPORTED_WITH_LICENSE_UPGRADE
+        if not operation_name:
+            return AwsServicesSupportInLatest.SUPPORTED
+        if operation_name in self.services_in_latest[service_name][self.current_emulator_type]:
+            return AwsServiceOperationsSupportInLatest.SUPPORTED
+        for emulator_type in self.services_in_latest[service_name]:
+            if emulator_type is self.current_emulator_type:
+                continue
+            if operation_name in self.services_in_latest[service_name][emulator_type]:
+                return AwsServiceOperationsSupportInLatest.SUPPORTED_WITH_LICENSE_UPGRADE
+        return AwsServiceOperationsSupportInLatest.NOT_SUPPORTED
+
+    def get_cloudformation_resource_status(
+        self, resource_name: str, service_name: str, is_pro_resource: bool = False
+    ) -> CfnResourceSupportStatus | AwsServicesSupportInLatest | None:
+        if resource_name in self.cfn_resources_at_runtime:
+            return CloudFormationResourcesSupportAtRuntime.AVAILABLE
+        if service_name in self.services_at_runtime:
+            if resource_name in self.cfn_resources_in_latest[self.current_emulator_type]:
+                return CloudFormationResourcesSupportInLatest.SUPPORTED
+            else:
+                return CloudFormationResourcesSupportInLatest.NOT_SUPPORTED
+        if service_name in self.services_in_latest:
+            return self.get_aws_service_status(service_name, operation_name=None)
+        return AwsServicesSupportInLatest.NOT_SUPPORTED

localstack/utils/catalog/catalog_loader.py

@@ -0,0 +1,119 @@
+import json
+import logging
+from json import JSONDecodeError
+from pathlib import Path
+
+import requests
+from pydantic import BaseModel
+
+from localstack import config, constants
+from localstack.utils.catalog.common import AwsRemoteCatalog
+from localstack.utils.http import get_proxies
+from localstack.utils.json import FileMappedDocument
+
+LOG = logging.getLogger(__name__)
+
+AWS_CATALOG_FILE_NAME = "aws_catalog.json"
+
+
+class RemoteCatalogVersionResponse(BaseModel):
+    emulator_type: str
+    version: str
+
+
+class AwsCatalogLoaderException(Exception):
+    def __init__(self, msg: str, *args):
+        super().__init__(msg, *args)
+
+
+class RemoteCatalogLoader:
+    supported_schema_version = "v1"
+    api_endpoint_catalog = f"{constants.API_ENDPOINT}/license/catalog"
+    catalog_file_path = Path(config.dirs.cache) / AWS_CATALOG_FILE_NAME
+
+    def get_remote_catalog(self) -> AwsRemoteCatalog:
+        catalog_doc = FileMappedDocument(self.catalog_file_path)
+        cached_catalog = AwsRemoteCatalog(**catalog_doc) if catalog_doc else None
+        if cached_catalog:
+            cached_catalog_version = cached_catalog.localstack.version
+            if not self._should_update_cached_catalog(cached_catalog_version):
+                return cached_catalog
+        catalog = self._get_catalog_from_platform()
+        self._save_catalog_to_cache(catalog_doc, catalog)
+        return catalog
+
+    def _get_latest_localstack_version(self) -> str:
+        try:
+            proxies = get_proxies()
+            response = requests.get(
+                f"{self.api_endpoint_catalog}/aws/version",
+                verify=not config.is_env_true("SSL_NO_VERIFY"),
+                proxies=proxies,
+            )
+            if response.ok:
+                return RemoteCatalogVersionResponse.model_validate(response.content).version
+            self._raise_server_error(response)
+        except requests.exceptions.RequestException as e:
+            raise AwsCatalogLoaderException(
+                f"An unexpected network error occurred when trying to fetch latest localstack version: {e}"
+            ) from e
+
+    def _should_update_cached_catalog(self, current_catalog_version: str) -> bool:
+        try:
+            latest_version = self._get_latest_localstack_version()
+            return latest_version != current_catalog_version
+        except Exception as e:
+            LOG.warning(
+                "Failed to retrieve the latest catalog version, cached catalog update skipped: %s",
+                e,
+            )
+            return False
+
+    def _save_catalog_to_cache(self, catalog_doc: FileMappedDocument, catalog: AwsRemoteCatalog):
+        catalog_doc.clear()
+        catalog_doc.update(catalog.model_dump())
+        catalog_doc.save()
+
+    def _get_catalog_from_platform(self) -> AwsRemoteCatalog:
+        try:
+            proxies = get_proxies()
+            response = requests.post(
+                self.api_endpoint_catalog,
+                verify=not config.is_env_true("SSL_NO_VERIFY"),
+                proxies=proxies,
+            )
+
+            if response.ok:
+                return self._parse_catalog(response.content)
+            self._raise_server_error(response)
+        except requests.exceptions.RequestException as e:
+            raise AwsCatalogLoaderException(
+                f"An unexpected network error occurred when trying to fetch remote catalog: {e}"
+            ) from e
+
+    def _parse_catalog(self, document: bytes) -> AwsRemoteCatalog | None:
+        try:
+            catalog_json = json.loads(document)
+        except JSONDecodeError as e:
+            raise AwsCatalogLoaderException(f"Could not de-serialize json catalog: {e}") from e
+        remote_catalog = AwsRemoteCatalog.model_validate(catalog_json)
+        if remote_catalog.schema_version != self.supported_schema_version:
+            raise AwsCatalogLoaderException(
+                f"Unsupported schema version: '{remote_catalog.schema_version}'. Only '{self.supported_schema_version}' is supported"
+            )
+        return remote_catalog
+
+    def _raise_server_error(self, response: requests.Response):
+        try:
+            server_error = response.json()
+            if error_message := server_error.get("message"):
+                raise AwsCatalogLoaderException(
+                    f"Unexpected AWS catalog server error: {response.text}"
+                )
+            raise AwsCatalogLoaderException(
+                f"A server error occurred while calling remote catalog API (HTTP {response.status_code}): {error_message}"
+            )
+        except Exception:
+            raise AwsCatalogLoaderException(
+                f"An unexpected server error occurred while calling remote catalog API (HTTP {response.status_code}): {response.text}"
+            )

localstack/utils/catalog/common.py

@@ -0,0 +1,58 @@
+from enum import StrEnum
+
+from pydantic import BaseModel
+
+
+class CloudFormationResource(BaseModel):
+    methods: list[str]
+
+
+class AwsServiceCatalog(BaseModel):
+    provider: str
+    operations: list[str]
+    plans: list[str]
+
+
+class LocalStackMetadata(BaseModel):
+    version: str
+
+
+class AwsRemoteCatalog(BaseModel):
+    schema_version: str
+    localstack: LocalStackMetadata
+    services: dict[str, dict[str, AwsServiceCatalog]]
+    cloudformation_resources: dict[str, dict[str, CloudFormationResource]]
+
+
+class LocalstackEmulatorType(StrEnum):
+    COMMUNITY = "community"
+    PRO = "pro"
+
+
+class AwsServiceSupportAtRuntime(StrEnum):
+    AVAILABLE = "AVAILABLE"
+    AVAILABLE_WITH_LICENSE_UPGRADE = "AVAILABLE_WITH_LICENSE_UPGRADE"
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"
+
+
+class AwsServicesSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    SUPPORTED_WITH_LICENSE_UPGRADE = "SUPPORTED_WITH_LICENSE_UPGRADE"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+    NON_DEFAULT_PROVIDER = "NON_DEFAULT_PROVIDER"
+
+
+class AwsServiceOperationsSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    SUPPORTED_WITH_LICENSE_UPGRADE = "SUPPORTED_WITH_LICENSE_UPGRADE"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+
+
+class CloudFormationResourcesSupportInLatest(StrEnum):
+    SUPPORTED = "SUPPORTED"
+    NOT_SUPPORTED = "NOT_SUPPORTED"
+
+
+class CloudFormationResourcesSupportAtRuntime(StrEnum):
+    AVAILABLE = "AVAILABLE"
+    NOT_IMPLEMENTED = "NOT_IMPLEMENTED"

localstack/utils/catalog/plugins.py

@@ -0,0 +1,28 @@
+import logging
+
+from plux import PluginManager
+
+from localstack.utils.catalog.catalog import CatalogPlugin
+from localstack.utils.objects import singleton_factory
+
+LOG = logging.getLogger(__name__)
+
+
+@singleton_factory
+def get_aws_catalog() -> CatalogPlugin:
+    plugin_manager = PluginManager(CatalogPlugin.namespace)
+    try:
+        plugin_name = "aws-catalog-remote-state-with-license"
+        if not plugin_manager.exists(plugin_name):
+            plugin_name = "aws-catalog-remote-state"
+        return plugin_manager.load(plugin_name)
+    except Exception as e:
+        LOG.debug(
+            "Failed to load catalog plugin with the latest LocalStack services support data, falling back to catalog without remote state: %s",
+            e,
+        )
+        # Try to load runtime catalog from pro version first
+        fallback_plugin_name = "aws-catalog-runtime-only-with-license"
+        if not plugin_manager.exists(fallback_plugin_name):
+            fallback_plugin_name = "aws-catalog-runtime-only"
+        return plugin_manager.load(fallback_plugin_name)

localstack/utils/cloudwatch/cloudwatch_util.py

@@ -2,7 +2,7 @@ import logging
 import time
 from datetime import datetime, timezone
 from itertools import islice
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 from werkzeug import Response as WerkzeugResponse
 
@@ -20,8 +20,8 @@ LOG = logging.getLogger(__name__)
 class SqsMetricBatchData(TypedDict, total=False):
     MetricName: str
     QueueName: str
-    Value: Optional[int]
-    Unit: Optional[str]
+    Value: int | None
+    Unit: str | None
 
 
 def dimension_lambda(kwargs):
@@ -30,7 +30,7 @@ def dimension_lambda(kwargs):
 
 
 def publish_lambda_metric(
-    metric, value, kwargs, account_id: Optional[str] = None, region_name: Optional[str] = None
+    metric, value, kwargs, account_id: str | None = None, region_name: str | None = None
 ):
     # publish metric only if CloudWatch service is available
     if not is_api_enabled("cloudwatch"):
@@ -155,7 +155,7 @@ def store_cloudwatch_logs(
     log_stream_name,
     log_output,
     start_time=None,
-    auto_create_group: Optional[bool] = True,
+    auto_create_group: bool | None = True,
 ):
     if not is_api_enabled("logs"):
         return