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

localstack/aws/spec-patches.json

@@ -1329,6 +1329,26 @@
         "documentation": "<p>The Content-MD5 you specified did not match what we received.</p>",
         "exception": true
       }
+    },
+    {
+      "op": "add",
+      "path": "/shapes/AuthorizationHeaderMalformed",
+      "value": {
+        "type": "structure",
+        "members": {
+          "Region": {
+            "shape": "BucketRegion"
+          },
+          "HostId": {
+            "shape": "HostId"
+          }
+        },
+        "error": {
+          "httpStatusCode": 400
+        },
+        "documentation": "<p>The authorization header is malformed.</p>",
+        "exception": true
+      }
     }
   ],
   "apigatewayv2/2018-11-29/service-2": [
@@ -1352,5 +1372,43 @@
       "path": "/operations/CreateApiMapping/http/responseCode",
       "value": 200
     }
+  ],
+  "cloudwatch/2010-08-01/service-2": [
+    {
+      "op": "add",
+      "path": "/metadata/awsQueryCompatible",
+      "value": {}
+    },
+    {
+      "op": "add",
+      "path": "/metadata/jsonVersion",
+      "value": "1.0"
+    },
+    {
+      "op": "add",
+      "path": "/metadata/targetPrefix",
+      "value": "GraniteServiceVersion20100801"
+    },
+    {
+      "op": "replace",
+      "path": "/metadata/protocol",
+      "value": "smithy-rpc-v2-cbor"
+    },
+    {
+      "op": "replace",
+      "path": "/metadata/protocols",
+      "value": [
+        "smithy-rpc-v2-cbor",
+        "json",
+        "query"
+      ]
+    },
+    {
+      "op": "add",
+      "path": "/shapes/ConflictException/error",
+      "value": {
+        "httpStatusCode": 409
+      }
+    }
   ]
 }

localstack/aws/spec.py

@@ -4,8 +4,9 @@ import logging
 import os
 import sys
 from collections import defaultdict
+from collections.abc import Generator
 from functools import cached_property, lru_cache
-from typing import Dict, Generator, List, Literal, NamedTuple, Optional, Tuple
+from typing import Literal, NamedTuple
 
 import botocore
 import jsonpatch
@@ -20,7 +21,7 @@ from localstack.utils.objects import singleton_factory
 LOG = logging.getLogger(__name__)
 
 ServiceName = str
-ProtocolName = Literal["query", "json", "rest-json", "rest-xml", "ec2"]
+ProtocolName = Literal["query", "json", "rest-json", "rest-xml", "ec2", "smithy-rpc-v2-cbor"]
 
 
 class ServiceModelIdentifier(NamedTuple):
@@ -31,13 +32,14 @@ class ServiceModelIdentifier(NamedTuple):
     """
 
     name: ServiceName
-    protocol: Optional[ProtocolName] = None
+    protocol: ProtocolName | None = None
+    protocols: tuple[ProtocolName] | None = None
 
 
 spec_patches_json = os.path.join(os.path.dirname(__file__), "spec-patches.json")
 
 
-def load_spec_patches() -> Dict[str, list]:
+def load_spec_patches() -> dict[str, list]:
     if not os.path.exists(spec_patches_json):
         return {}
     with open(spec_patches_json) as fd:
@@ -59,16 +61,16 @@ class PatchingLoader(Loader):
     A custom botocore Loader that applies JSON patches from the given json patch file to the specs as they are loaded.
     """
 
-    patches: Dict[str, list]
+    patches: dict[str, list]
 
-    def __init__(self, patches: Dict[str, list], *args, **kwargs):
+    def __init__(self, patches: dict[str, list], *args, **kwargs):
         # add the builtin data path to the extra_search_paths to ensure they are discovered by the loader
         super().__init__(*args, **kwargs)
         self.patches = patches
 
     @instance_cache
     def load_data(self, name: str):
-        result = super(PatchingLoader, self).load_data(name)
+        result = super().load_data(name)
 
         if patches := self.patches.get(name):
             return jsonpatch.apply_patch(result, patches)
@@ -94,12 +96,12 @@ class UnknownServiceProtocolError(UnknownServiceError):
     fmt = "Unknown service protocol: '{service_name}-{protocol}'."
 
 
-def list_services() -> List[ServiceModel]:
+def list_services() -> list[ServiceModel]:
     return [load_service(service) for service in loader.list_available_services("service-2")]
 
 
 def load_service(
-    service: ServiceName, version: Optional[str] = None, protocol: Optional[ProtocolName] = None
+    service: ServiceName, version: str | None = None, protocol: ProtocolName | None = None
 ) -> ServiceModel:
     """
     Loads a service
@@ -113,9 +115,13 @@ def load_service(
     :raises: UnknownServiceProtocolError if the specific protocol of the service cannot be found
     """
     service_description = loader.load_service_model(service, "service-2", version)
+    service_metadata = service_description.get("metadata", {})
+    service_protocols = {service_metadata.get("protocol")}
+    if protocols := service_metadata.get("protocols"):
+        service_protocols.update(protocols)
 
     # check if the protocol is defined, and if so, if the loaded service defines this protocol
-    if protocol is not None and protocol != service_description.get("metadata", {}).get("protocol"):
+    if protocol is not None and protocol not in service_protocols:
         # if the protocol is defined, but not the one of the currently loaded service,
         # check if we already loaded the custom spec based on the naming convention (<service>-<protocol>),
         # f.e. "sqs-query"
@@ -131,12 +137,12 @@ def load_service(
 
     # remove potential protocol names from the service name
     # FIXME add more protocols here if we have to internalize more than just sqs-query
-    # TODO this should not contain specific internalized serivce names
+    # TODO this should not contain specific internalized service names
     service = {"sqs-query": "sqs"}.get(service, service)
     return ServiceModel(service_description, service)
 
 
-def iterate_service_operations() -> Generator[Tuple[ServiceModel, OperationModel], None, None]:
+def iterate_service_operations() -> Generator[tuple[ServiceModel, OperationModel], None, None]:
     """
     Returns one record per operation in the AWS service spec, where the first item is the service model the operation
     belongs to, and the second is the operation model.
@@ -148,17 +154,38 @@ def iterate_service_operations() -> Generator[Tuple[ServiceModel, OperationModel
             yield service, service.operation_model(op_name)
 
 
+def is_protocol_in_service_model_identifier(
+    protocol: ProtocolName, service_model_identifier: ServiceModelIdentifier
+) -> bool:
+    """
+    :param protocol: the protocol name to check
+    :param service_model_identifier:
+    :return: boolean to indicate if the protocol is available for that service
+    """
+    protocols = service_model_identifier.protocols or []
+    return protocol in protocols or protocol == service_model_identifier.protocol
+
+
+def get_service_model_identifier(service_model: ServiceModel) -> ServiceModelIdentifier:
+    protocols = service_model.metadata.get("protocols")
+    return ServiceModelIdentifier(
+        name=service_model.service_name,
+        protocol=service_model.protocol,
+        protocols=tuple(protocols) if protocols else None,
+    )
+
+
 @dataclasses.dataclass
 class ServiceCatalogIndex:
     """
     The ServiceCatalogIndex enables fast lookups for common operations to determine a service from service indicators.
     """
 
-    service_names: List[ServiceName]
-    target_prefix_index: Dict[str, List[ServiceModelIdentifier]]
-    signing_name_index: Dict[str, List[ServiceModelIdentifier]]
-    operations_index: Dict[str, List[ServiceModelIdentifier]]
-    endpoint_prefix_index: Dict[str, List[ServiceModelIdentifier]]
+    service_names: list[ServiceName]
+    target_prefix_index: dict[str, list[ServiceModelIdentifier]]
+    signing_name_index: dict[str, list[ServiceModelIdentifier]]
+    operations_index: dict[str, list[ServiceModelIdentifier]]
+    endpoint_prefix_index: dict[str, list[ServiceModelIdentifier]]
 
 
 class LazyServiceCatalogIndex:
@@ -167,58 +194,52 @@ class LazyServiceCatalogIndex:
     """
 
     @cached_property
-    def service_names(self) -> List[ServiceName]:
+    def service_names(self) -> list[ServiceName]:
         return list(self._services.keys())
 
     @cached_property
-    def target_prefix_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def target_prefix_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         result = defaultdict(list)
         for service_models in self._services.values():
             for service_model in service_models:
                 target_prefix = service_model.metadata.get("targetPrefix")
                 if target_prefix:
-                    result[target_prefix].append(
-                        ServiceModelIdentifier(service_model.service_name, service_model.protocol)
-                    )
+                    result[target_prefix].append(get_service_model_identifier(service_model))
         return dict(result)
 
     @cached_property
-    def signing_name_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def signing_name_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         result = defaultdict(list)
         for service_models in self._services.values():
             for service_model in service_models:
                 result[service_model.signing_name].append(
-                    ServiceModelIdentifier(service_model.service_name, service_model.protocol)
+                    get_service_model_identifier(service_model)
                 )
         return dict(result)
 
     @cached_property
-    def operations_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def operations_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         result = defaultdict(list)
         for service_models in self._services.values():
             for service_model in service_models:
                 operations = service_model.operation_names
                 if operations:
                     for operation in operations:
-                        result[operation].append(
-                            ServiceModelIdentifier(
-                                service_model.service_name, service_model.protocol
-                            )
-                        )
+                        result[operation].append(get_service_model_identifier(service_model))
         return dict(result)
 
     @cached_property
-    def endpoint_prefix_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def endpoint_prefix_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         result = defaultdict(list)
         for service_models in self._services.values():
             for service_model in service_models:
                 result[service_model.endpoint_prefix].append(
-                    ServiceModelIdentifier(service_model.service_name, service_model.protocol)
+                    get_service_model_identifier(service_model)
                 )
         return dict(result)
 
     @cached_property
-    def _services(self) -> Dict[ServiceName, List[ServiceModel]]:
+    def _services(self) -> dict[ServiceName, list[ServiceModel]]:
         services = defaultdict(list)
         for service in list_services():
             services[service.service_name].append(service)
@@ -232,38 +253,36 @@ class ServiceCatalog:
         self.index = index or LazyServiceCatalogIndex()
 
     @lru_cache(maxsize=512)
-    def get(
-        self, name: ServiceName, protocol: Optional[ProtocolName] = None
-    ) -> Optional[ServiceModel]:
+    def get(self, name: ServiceName, protocol: ProtocolName | None = None) -> ServiceModel | None:
         return load_service(name, protocol=protocol)
 
     @property
-    def service_names(self) -> List[ServiceName]:
+    def service_names(self) -> list[ServiceName]:
         return self.index.service_names
 
     @property
-    def target_prefix_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def target_prefix_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         return self.index.target_prefix_index
 
     @property
-    def signing_name_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def signing_name_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         return self.index.signing_name_index
 
     @property
-    def operations_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def operations_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         return self.index.operations_index
 
     @property
-    def endpoint_prefix_index(self) -> Dict[str, List[ServiceModelIdentifier]]:
+    def endpoint_prefix_index(self) -> dict[str, list[ServiceModelIdentifier]]:
         return self.index.endpoint_prefix_index
 
-    def by_target_prefix(self, target_prefix: str) -> List[ServiceModelIdentifier]:
+    def by_target_prefix(self, target_prefix: str) -> list[ServiceModelIdentifier]:
         return self.target_prefix_index.get(target_prefix, [])
 
-    def by_signing_name(self, signing_name: str) -> List[ServiceModelIdentifier]:
+    def by_signing_name(self, signing_name: str) -> list[ServiceModelIdentifier]:
         return self.signing_name_index.get(signing_name, [])
 
-    def by_operation(self, operation_name: str) -> List[ServiceModelIdentifier]:
+    def by_operation(self, operation_name: str) -> list[ServiceModelIdentifier]:
         return self.operations_index.get(operation_name, [])
 
 
@@ -344,8 +363,9 @@ def get_service_catalog() -> ServiceCatalog:
                 index = build_service_index_cache(cache_catalog_file)
         return ServiceCatalog(index)
     except Exception:
-        LOG.exception(
-            "error while processing service catalog index cache, falling back to lazy-loaded index"
+        LOG.error(
+            "error while processing service catalog index cache, falling back to lazy-loaded index",
+            exc_info=LOG.isEnabledFor(logging.DEBUG),
         )
         return ServiceCatalog()
 

localstack/cli/exceptions.py

@@ -12,7 +12,7 @@ class CLIError(ClickException):
     def format_message(self) -> str:
         return click.style(f"❌ Error: {self.message}", fg="red")
 
-    def show(self, file: t.Optional[t.IO[t.Any]] = None) -> None:
+    def show(self, file: t.IO[t.Any] | None = None) -> None:
         if file is None:
             file = get_text_stderr()
 

localstack/cli/localstack.py

@@ -3,7 +3,7 @@ import logging
 import os
 import sys
 import traceback
-from typing import Dict, List, Optional, Tuple, TypedDict
+from typing import TypedDict
 
 import click
 import requests
@@ -47,7 +47,7 @@ class LocalStackCliGroup(click.Group):
 
     def invoke(self, ctx: click.Context):
         try:
-            return super(LocalStackCliGroup, self).invoke(ctx)
+            return super().invoke(ctx)
         except click.exceptions.Exit:
             # raise Exit exceptions unmodified (e.g., raised on --help)
             raise
@@ -320,8 +320,8 @@ class DockerStatus(TypedDict, total=False):
     image_tag: str
     image_id: str
     image_created: str
-    container_name: Optional[str]
-    container_ip: Optional[str]
+    container_name: str | None
+    container_ip: str | None
 
 
 def _print_docker_status(format_: str) -> None:
@@ -405,7 +405,7 @@ def cmd_status_services(format_: str) -> None:
         raise CLIError(f"could not connect to LocalStack health endpoint at {url}")
 
 
-def _print_service_table(services: Dict[str, str]) -> None:
+def _print_service_table(services: dict[str, str]) -> None:
     from rich.table import Table
 
     status_display = {
@@ -486,9 +486,9 @@ def cmd_start(
     no_banner: bool,
     detached: bool,
     network: str = None,
-    env: Tuple = (),
-    publish: Tuple = (),
-    volume: Tuple = (),
+    env: tuple = (),
+    publish: tuple = (),
+    volume: tuple = (),
     host_dns: bool = False,
     stack: str = None,
 ) -> None:
@@ -602,7 +602,7 @@ def cmd_stop() -> None:
 
     try:
         DOCKER_CLIENT.stop_container(container_name)
-        console.print("container stopped: %s" % container_name)
+        console.print(f"container stopped: {container_name}")
     except NoSuchContainer:
         raise CLIError(
             f'Expected a running LocalStack container named "{container_name}", but found none'
@@ -699,7 +699,7 @@ def cmd_logs(follow: bool, tail: int) -> None:
     metavar="N",
 )
 @publish_invocation
-def cmd_wait(timeout: Optional[float] = None) -> None:
+def cmd_wait(timeout: float | None = None) -> None:
     """
     Wait for the LocalStack runtime to be up and running.
 
@@ -825,7 +825,7 @@ def cmd_update_docker_images() -> None:
     update_images(localstack_images)
 
 
-def update_images(image_list: List[str]) -> None:
+def update_images(image_list: list[str]) -> None:
     from rich.markup import escape
     from rich.progress import MofNCompleteColumn, Progress
 

localstack/cli/lpm.py

@@ -1,7 +1,6 @@
 import itertools
 import logging
 from multiprocessing.pool import ThreadPool
-from typing import List, Optional
 
 import click
 from rich.console import Console
@@ -74,10 +73,10 @@ def _do_install_package(package: Package, version: str = None, target: InstallTa
     help="target of the installation",
 )
 def install(
-    package: List[str],
-    parallel: Optional[int] = 1,
-    version: Optional[str] = None,
-    target: Optional[str] = None,
+    package: list[str],
+    parallel: int | None = 1,
+    version: str | None = None,
+    target: str | None = None,
 ):
     """Install one or more packages."""
     try:

localstack/cli/plugins.py

@@ -56,7 +56,7 @@ def find(where, exclude, include, output):
     elif output == "dict":
         rprint(dict(plugins))
     else:
-        raise CLIError("unknown output format %s" % output)
+        raise CLIError(f"unknown output format {output}")
 
 
 @cli.command("list")

localstack/cli/profiles.py

@@ -1,7 +1,6 @@
 import argparse
 import os
 import sys
-from typing import Optional
 
 # important: this needs to be free of localstack imports
 
@@ -44,7 +43,7 @@ def set_and_remove_profile_from_sys_argv():
         os.environ["CONFIG_PROFILE"] = profile.strip()
 
 
-def parse_p_argument(args) -> Optional[str]:
+def parse_p_argument(args) -> str | None:
     """
     Lightweight arg parsing to find the first occurrence of ``-p <config>``, or ``-p=<config>`` and return the value of
     ``<config>`` from the given arguments.