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

localstack/services/apigateway/legacy/provider.py

@@ -323,8 +323,18 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         tags: MapOfStringToString = None,
         **kwargs,
     ) -> ApiKey:
+        if name and len(name) > 1024:
+            raise BadRequestException("Invalid API Key name, can be at most 1024 characters.")
+        if value:
+            if len(value) > 128:
+                raise BadRequestException("API Key value exceeds maximum size of 128 characters")
+            elif len(value) < 20:
+                raise BadRequestException("API Key value should be at least 20 characters")
+        if description and len(description) > 125000:
+            raise BadRequestException("Invalid API Key description specified.")
         api_key = call_moto(context)
-
+        if name == "":
+            api_key.pop("name", None)
         #  transform array of stage keys [{'restApiId': '0iscapk09u', 'stageName': 'dev'}] into
         #  array of strings ['0iscapk09u/dev']
         stage_keys = api_key.get("stageKeys", [])
@@ -665,66 +675,6 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         parent_id = moto_resource.parent_id
         api_resources[parent_id].remove(resource_id)
 
-    def update_integration_response(
-        self,
-        context: RequestContext,
-        rest_api_id: String,
-        resource_id: String,
-        http_method: String,
-        status_code: StatusCode,
-        patch_operations: ListOfPatchOperation = None,
-        **kwargs,
-    ) -> IntegrationResponse:
-        # XXX: THIS IS NOT A COMPLETE IMPLEMENTATION, just the minimum required to get tests going
-        # TODO: validate patch operations
-
-        moto_rest_api = get_moto_rest_api(context, rest_api_id)
-        moto_resource = moto_rest_api.resources.get(resource_id)
-        if not moto_resource:
-            raise NotFoundException("Invalid Resource identifier specified")
-
-        moto_method = moto_resource.resource_methods.get(http_method)
-        if not moto_method:
-            raise NotFoundException("Invalid Method identifier specified")
-
-        integration_response = moto_method.method_integration.integration_responses.get(status_code)
-        if not integration_response:
-            raise NotFoundException("Invalid Integration Response identifier specified")
-
-        for patch_operation in patch_operations:
-            op = patch_operation.get("op")
-            path = patch_operation.get("path")
-
-            # for path "/responseTemplates/application~1json"
-            if "/responseTemplates" in path:
-                integration_response.response_templates = (
-                    integration_response.response_templates or {}
-                )
-                value = patch_operation.get("value")
-                if not isinstance(value, str):
-                    raise BadRequestException(
-                        f"Invalid patch value  '{value}' specified for op '{op}'. Must be a string"
-                    )
-                param = path.removeprefix("/responseTemplates/")
-                param = param.replace("~1", "/")
-                if op == "remove":
-                    integration_response.response_templates.pop(param)
-                elif op in ("add", "replace"):
-                    integration_response.response_templates[param] = value
-
-            elif "/contentHandling" in path and op == "replace":
-                integration_response.content_handling = patch_operation.get("value")
-
-            elif "/selectionPattern" in path and op == "replace":
-                integration_response.selection_pattern = patch_operation.get("value")
-
-        response: IntegrationResponse = integration_response.to_json()
-        # in case it's empty, we still want to pass it on as ""
-        # TODO: add a test case for this
-        response["selectionPattern"] = integration_response.selection_pattern
-
-        return response
-
     def update_resource(
         self,
         context: RequestContext,
@@ -757,6 +707,9 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
                     f"Invalid patch path  '{path}' specified for op '{op}'. Please choose supported operations"
                 )
 
+            if moto_resource.parent_id is None:
+                raise BadRequestException(f"Root resource cannot update its {path.strip('/')}.")
+
             if path == "/parentId":
                 value = patch_operation.get("value")
                 future_parent_resource = moto_rest_api.resources.get(value)
@@ -793,7 +746,7 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
                     api_resources.pop(current_parent_id)
 
         # add it to the new parent children
-        future_sibling_resources = api_resources[moto_resource.parent_id]
+        future_sibling_resources = api_resources.setdefault(moto_resource.parent_id, [])
         future_sibling_resources.append(resource_id)
 
         response = moto_resource.to_dict()
@@ -2111,6 +2064,20 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
             for integration_response in integration_responses.values():
                 remove_empty_attributes_from_integration_response(integration_response)
 
+        if response.get("connectionType") == "VPC_LINK":
+            # FIXME: this is hacky to workaround moto not saving the VPC Link `connectionId`
+            # only do this internal check of Moto if the integration is of VPC_LINK type
+            moto_rest_api = get_moto_rest_api(context=context, rest_api_id=rest_api_id)
+            try:
+                method = moto_rest_api.resources[resource_id].resource_methods[http_method]
+                integration = method.method_integration
+                if connection_id := getattr(integration, "connection_id", None):
+                    response["connectionId"] = connection_id
+
+            except (AttributeError, KeyError):
+                # this error should have been caught by `call_moto`
+                pass
+
         return response
 
     def put_integration(
@@ -2165,6 +2132,7 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         moto_request.setdefault("timeoutInMillis", 29000)
         if integration_type in (IntegrationType.HTTP, IntegrationType.HTTP_PROXY):
             moto_request.setdefault("connectionType", ConnectionType.INTERNET)
+
         response = call_moto_with_request(context, moto_request)
         remove_empty_attributes_from_integration(integration=response)
 
@@ -2172,6 +2140,13 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         if integration_type == "MOCK":
             response.pop("uri", None)
 
+        # TODO: moto does not save the connection_id
+        elif moto_request.get("connectionType") == "VPC_LINK":
+            connection_id = moto_request.get("connectionId", "")
+            # attach the connection id to the moto object
+            method.method_integration.connection_id = connection_id
+            response["connectionId"] = connection_id
+
         return response
 
     def update_integration(
@@ -2193,6 +2168,7 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
             raise NotFoundException("Invalid Integration identifier specified")
 
         integration = method.method_integration
+        # TODO: validate the patch operations
         patch_api_gateway_entity(integration, patch_operations)
 
         # fix data types
@@ -2201,8 +2177,12 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         if skip_verification := (integration.tls_config or {}).get("insecureSkipVerification"):
             integration.tls_config["insecureSkipVerification"] = str_to_bool(skip_verification)
 
-        integration_dict: Integration = integration.to_json()
-        return integration_dict
+        response: Integration = integration.to_json()
+
+        if connection_id := getattr(integration, "connection_id", None):
+            response["connectionId"] = connection_id
+
+        return response
 
     def delete_integration(
         self,
@@ -2307,6 +2287,93 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
 
         return response
 
+    def update_integration_response(
+        self,
+        context: RequestContext,
+        rest_api_id: String,
+        resource_id: String,
+        http_method: String,
+        status_code: StatusCode,
+        patch_operations: ListOfPatchOperation = None,
+        **kwargs,
+    ) -> IntegrationResponse:
+        # XXX: THIS IS NOT A COMPLETE IMPLEMENTATION, just the minimum required to get tests going
+        # TODO: validate patch operations
+
+        moto_rest_api = get_moto_rest_api(context, rest_api_id)
+        moto_resource = moto_rest_api.resources.get(resource_id)
+        if not moto_resource:
+            raise NotFoundException("Invalid Resource identifier specified")
+
+        moto_method = moto_resource.resource_methods.get(http_method)
+        if not moto_method:
+            raise NotFoundException("Invalid Method identifier specified")
+
+        integration_response = moto_method.method_integration.integration_responses.get(status_code)
+        if not integration_response:
+            raise NotFoundException("Invalid Integration Response identifier specified")
+
+        for patch_operation in patch_operations:
+            op = patch_operation.get("op")
+            path = patch_operation.get("path")
+
+            # for path "/responseTemplates/application~1json"
+            if "/responseTemplates" in path:
+                integration_response.response_templates = (
+                    integration_response.response_templates or {}
+                )
+                value = patch_operation.get("value")
+                if not isinstance(value, str):
+                    raise BadRequestException(
+                        f"Invalid patch value  '{value}' specified for op '{op}'. Must be a string"
+                    )
+                param = path.removeprefix("/responseTemplates/")
+                param = param.replace("~1", "/")
+                if op == "remove":
+                    integration_response.response_templates.pop(param)
+                elif op in ("add", "replace"):
+                    integration_response.response_templates[param] = value
+
+            elif "/contentHandling" in path and op == "replace":
+                integration_response.content_handling = patch_operation.get("value")
+
+            elif "/selectionPattern" in path and op == "replace":
+                integration_response.selection_pattern = patch_operation.get("value")
+
+        response: IntegrationResponse = integration_response.to_json()
+        # in case it's empty, we still want to pass it on as ""
+        # TODO: add a test case for this
+        response["selectionPattern"] = integration_response.selection_pattern
+
+        return response
+
+    def delete_integration_response(
+        self,
+        context: RequestContext,
+        rest_api_id: String,
+        resource_id: String,
+        http_method: String,
+        status_code: StatusCode,
+        **kwargs,
+    ) -> None:
+        moto_backend = apigw_models.apigateway_backends[context.account_id][context.region]
+        moto_rest_api = moto_backend.apis.get(rest_api_id)
+        if not moto_rest_api:
+            raise NotFoundException("Invalid Resource identifier specified")
+
+        if not (moto_resource := moto_rest_api.resources.get(resource_id)):
+            raise NotFoundException("Invalid Resource identifier specified")
+
+        if not (moto_method := moto_resource.resource_methods.get(http_method)):
+            raise NotFoundException("Invalid Integration identifier specified")
+
+        if not moto_method.method_integration:
+            raise NotFoundException("Invalid Integration identifier specified")
+        if not (
+            integration_responses := moto_method.method_integration.integration_responses
+        ) or not integration_responses.pop(status_code, None):
+            raise NotFoundException("Invalid Response status code specified")
+
     def get_export(
         self,
         context: RequestContext,
@@ -2363,6 +2430,10 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
             for api_key in api_keys:
                 api_key.pop("value")
 
+        if limit is not None:
+            if limit < 1 or limit > 500:
+                limit = None
+
         item_list = PaginatedList(api_keys)
 
         def token_generator(item):
@@ -2387,6 +2458,14 @@ class ApigatewayProvider(ApigatewayApi, ServiceLifecycleHook):
         patch_operations: ListOfPatchOperation = None,
         **kwargs,
     ) -> ApiKey:
+        for patch_op in patch_operations:
+            if patch_op["path"] not in ("/description", "/enabled", "/name", "/customerId"):
+                raise BadRequestException(
+                    f"Invalid patch path  '{patch_op['path']}' specified for op '{patch_op['op']}'. Must be one of: [/description, /enabled, /name, /customerId]"
+                )
+
+            if patch_op["path"] == "/description" and len(patch_op["value"]) > 125000:
+                raise BadRequestException("Invalid API Key description specified.")
         response: ApiKey = call_moto(context)
         if "value" in response:
             response.pop("value", None)
@@ -2947,6 +3026,7 @@ def create_custom_context(
     ctx = create_aws_request_context(
         service_name=context.service.service_name,
         action=action,
+        protocol=context.service.protocol,
         parameters=parameters,
         region=context.region,
     )
@@ -2998,7 +3078,7 @@ def to_documentation_part_response_json(api_id, data):
 
 
 def to_base_mapping_response_json(domain_name, base_path, data):
-    self_link = "/domainnames/%s/basepathmappings/%s" % (domain_name, base_path)
+    self_link = f"/domainnames/{domain_name}/basepathmappings/{base_path}"
     result = to_response_json("basepathmapping", data, self_link=self_link)
     result = select_from_typed_dict(BasePathMapping, result)
     return result
@@ -3034,9 +3114,9 @@ def to_response_json(model_type, data, api_id=None, self_link=None, id_attr=None
     id_attr = id_attr or "id"
     result = deepcopy(data)
     if not self_link:
-        self_link = "/%ss/%s" % (model_type, data[id_attr])
+        self_link = f"/{model_type}s/{data[id_attr]}"
         if api_id:
-            self_link = "/restapis/%s/%s" % (api_id, self_link)
+            self_link = f"/restapis/{api_id}/{self_link}"
     # TODO: check if this is still required - "_links" are listed in the sample responses in the docs, but
     #  recent parity tests indicate that this field is not returned by real AWS...
     # https://docs.aws.amazon.com/apigateway/latest/api/API_GetAuthorizers.html#API_GetAuthorizers_Example_1_Response
@@ -3048,7 +3128,7 @@ def to_response_json(model_type, data, api_id=None, self_link=None, id_attr=None
         "name": model_type,
         "templated": True,
     }
-    result["_links"]["%s:delete" % model_type] = {"href": self_link}
+    result["_links"][f"{model_type}:delete"] = {"href": self_link}
     return result
 
 

localstack/services/apigateway/legacy/router_asf.py

@@ -1,5 +1,5 @@
 import logging
-from typing import Any, Dict
+from typing import Any
 
 from requests.models import Response as RequestsResponse
 from werkzeug.datastructures import Headers
@@ -22,7 +22,7 @@ LOG = logging.getLogger(__name__)
 # invocation context property decorators and use the url_params directly,
 # something asked for a long time.
 def to_invocation_context(
-    request: Request, url_params: Dict[str, Any] = None
+    request: Request, url_params: dict[str, Any] = None
 ) -> ApiInvocationContext:
     """
     Converts an HTTP Request object into an ApiInvocationContext.

localstack/services/apigateway/legacy/templates.py

@@ -3,7 +3,7 @@ import copy
 import json
 import logging
 from enum import Enum
-from typing import Any, Dict, Union
+from typing import Any
 from urllib.parse import quote_plus, unquote_plus
 
 import xmltodict
@@ -68,7 +68,7 @@ class AttributeDict(dict):
     """
 
     def __init__(self, *args, **kwargs):
-        super(AttributeDict, self).__init__(*args, **kwargs)
+        super().__init__(*args, **kwargs)
         for key, value in self.items():
             if isinstance(value, dict):
                 self[key] = AttributeDict(value)
@@ -184,7 +184,7 @@ class VelocityInput:
 class ApiGatewayVtlTemplate(VtlTemplate):
     """Util class for rendering VTL templates with API Gateway specific extensions"""
 
-    def prepare_namespace(self, variables, source: str = APIGW_SOURCE) -> Dict[str, Any]:
+    def prepare_namespace(self, variables, source: str = APIGW_SOURCE) -> dict[str, Any]:
         namespace = super().prepare_namespace(variables, source)
         if stage_var := variables.get("stage_variables") or {}:
             namespace["stageVariables"] = stage_var
@@ -203,7 +203,7 @@ class Templates:
     def __init__(self):
         self.vtl = ApiGatewayVtlTemplate()
 
-    def render(self, api_context: ApiInvocationContext) -> Union[bytes, str]:
+    def render(self, api_context: ApiInvocationContext) -> bytes | str:
         pass
 
     def render_vtl(self, template, variables):
@@ -250,7 +250,7 @@ class RequestTemplates(Templates):
 
     def render(
         self, api_context: ApiInvocationContext, template_key: str = APPLICATION_JSON
-    ) -> Union[bytes, str]:
+    ) -> bytes | str:
         LOG.debug(
             "Method request body before transformations: %s", to_str(api_context.data_as_string())
         )
@@ -278,7 +278,7 @@ class ResponseTemplates(Templates):
     template is used.
     """
 
-    def render(self, api_context: ApiInvocationContext, **kwargs) -> Union[bytes, str]:
+    def render(self, api_context: ApiInvocationContext, **kwargs) -> bytes | str:
         # XXX: keep backwards compatibility until we migrate all integrations to this new classes
         # api_context contains a response object that we want slowly remove from it
         data = kwargs.get("response", "")

localstack/services/apigateway/models.py

@@ -1,4 +1,4 @@
-from typing import Any, Dict, List
+from typing import Any
 
 from requests.structures import CaseInsensitiveDict
 
@@ -28,21 +28,21 @@ class RestApiContainer:
     # contains the RestApi dictionary. We're not making use of it yet, still using moto data.
     rest_api: RestApi
     # maps AuthorizerId -> Authorizer
-    authorizers: Dict[str, Authorizer]
+    authorizers: dict[str, Authorizer]
     # maps RequestValidatorId -> RequestValidator
-    validators: Dict[str, RequestValidator]
+    validators: dict[str, RequestValidator]
     # map DocumentationPartId -> DocumentationPart
-    documentation_parts: Dict[str, DocumentationPart]
+    documentation_parts: dict[str, DocumentationPart]
     # map doc version name -> DocumentationVersion
-    documentation_versions: Dict[str, DocumentationVersion]
+    documentation_versions: dict[str, DocumentationVersion]
     # not used yet, still in moto
-    gateway_responses: Dict[GatewayResponseType, GatewayResponse]
+    gateway_responses: dict[GatewayResponseType, GatewayResponse]
     # maps Model name -> Model
-    models: Dict[str, Model]
+    models: dict[str, Model]
     # maps Model name -> resolved dict Model, so we don't need to load the JSON everytime
-    resolved_models: Dict[str, dict]
+    resolved_models: dict[str, dict]
     # maps ResourceId of a Resource to its children ResourceIds
-    resource_children: Dict[str, List[str]]
+    resource_children: dict[str, list[str]]
 
     def __init__(self, rest_api: RestApi):
         self.rest_api = rest_api
@@ -102,25 +102,25 @@ class RestApiDeployment:
 class ApiGatewayStore(BaseStore):
     # maps (API id) -> RestApiContainer
     # TODO: remove CaseInsensitiveDict, and lower the value of the ID when getting it from the tags
-    rest_apis: Dict[str, RestApiContainer] = LocalAttribute(default=CaseInsensitiveDict)
+    rest_apis: dict[str, RestApiContainer] = LocalAttribute(default=CaseInsensitiveDict)
 
     # account details
-    _account: Dict[str, Any] = LocalAttribute(default=dict)
+    _account: dict[str, Any] = LocalAttribute(default=dict)
 
     # maps (domain_name) -> [path_mappings]
-    base_path_mappings: Dict[str, List[Dict]] = LocalAttribute(default=dict)
+    base_path_mappings: dict[str, list[dict]] = LocalAttribute(default=dict)
 
     # maps ID to VPC link details
-    vpc_links: Dict[str, Dict] = LocalAttribute(default=dict)
+    vpc_links: dict[str, dict] = LocalAttribute(default=dict)
 
     # maps cert ID to client certificate details
-    client_certificates: Dict[str, Dict] = LocalAttribute(default=dict)
+    client_certificates: dict[str, dict] = LocalAttribute(default=dict)
 
     # maps domain name to domain name model
-    domain_names: Dict[str, DomainName] = LocalAttribute(default=dict)
+    domain_names: dict[str, DomainName] = LocalAttribute(default=dict)
 
     # maps resource ARN to tags
-    TAGS: Dict[str, Dict[str, str]] = CrossRegionAttribute(default=dict)
+    TAGS: dict[str, dict[str, str]] = CrossRegionAttribute(default=dict)
 
     # internal deployments, represents a frozen REST API for a deployment, used in our router
     # TODO: make sure API ID are unique across all accounts

localstack/services/apigateway/next_gen/execute_api/api.py

@@ -1,4 +1,4 @@
-from typing import Callable, Type
+from collections.abc import Callable
 
 from rolo import Response
 from rolo.gateway.chain import HandlerChain as RoloHandlerChain
@@ -14,4 +14,4 @@ RestApiGatewayExceptionHandler = Callable[
     None,
 ]
 
-RestApiGatewayHandlerChain: Type[RoloHandlerChain[RestApiInvocationContext]] = RoloHandlerChain
+RestApiGatewayHandlerChain: type[RoloHandlerChain[RestApiInvocationContext]] = RoloHandlerChain

localstack/services/apigateway/next_gen/execute_api/context.py

@@ -1,5 +1,5 @@
 from http import HTTPMethod
-from typing import Optional, TypedDict
+from typing import TypedDict
 
 from rolo import Request
 from rolo.gateway import RequestContext
@@ -14,12 +14,12 @@ from .variables import ContextVariableOverrides, ContextVariables, LoggingContex
 class InvocationRequest(TypedDict, total=False):
     http_method: HTTPMethod
     """HTTP Method of the incoming request"""
-    raw_path: Optional[str]
+    raw_path: str | None
     # TODO: verify if raw_path is needed
     """Raw path of the incoming request with no modification, needed to keep double forward slashes"""
-    path: Optional[str]
+    path: str | None
     """Path of the request with no URL decoding"""
-    path_parameters: Optional[dict[str, str]]
+    path_parameters: dict[str, str] | None
     """Path parameters of the request"""
     query_string_parameters: dict[str, str]
     """Query string parameters of the request"""
@@ -72,48 +72,48 @@ class RestApiInvocationContext(RequestContext):
     This context is going to be used to pass relevant information across an API Gateway invocation.
     """
 
-    deployment: Optional[RestApiDeployment]
+    deployment: RestApiDeployment | None
     """Contains the invoked REST API Resources"""
-    integration: Optional[Integration]
+    integration: Integration | None
     """The Method Integration for the invoked request"""
-    api_id: Optional[str]
+    api_id: str | None
     """The REST API identifier of the invoked API"""
-    stage: Optional[str]
+    stage: str | None
     """The REST API stage name linked to this invocation"""
-    base_path: Optional[str]
+    base_path: str | None
     """The REST API base path mapped to the stage of this invocation"""
-    deployment_id: Optional[str]
+    deployment_id: str | None
     """The REST API deployment linked to this invocation"""
-    region: Optional[str]
+    region: str | None
     """The region the REST API is living in."""
-    account_id: Optional[str]
+    account_id: str | None
     """The account the REST API is living in."""
-    trace_id: Optional[str]
+    trace_id: str | None
     """The X-Ray trace ID for the request."""
-    resource: Optional[Resource]
+    resource: Resource | None
     """The resource the invocation matched"""
-    resource_method: Optional[Method]
+    resource_method: Method | None
     """The method of the resource the invocation matched"""
-    stage_variables: Optional[dict[str, str]]
+    stage_variables: dict[str, str] | None
     """The Stage variables, also used in parameters mapping and mapping templates"""
-    stage_configuration: Optional[Stage]
+    stage_configuration: Stage | None
     """The Stage configuration, containing canary deployment settings"""
-    is_canary: Optional[bool]
+    is_canary: bool | None
     """If the current call was directed to a canary deployment"""
-    context_variables: Optional[ContextVariables]
+    context_variables: ContextVariables | None
     """The $context used in data models, authorizers, mapping templates, and CloudWatch access logging"""
-    context_variable_overrides: Optional[ContextVariableOverrides]
+    context_variable_overrides: ContextVariableOverrides | None
     """requestOverrides and responseOverrides are passed from request templates to response templates but are
     not in the integration context"""
-    logging_context_variables: Optional[LoggingContextVariables]
+    logging_context_variables: LoggingContextVariables | None
     """Additional $context variables available only for access logging, not yet implemented"""
-    invocation_request: Optional[InvocationRequest]
+    invocation_request: InvocationRequest | None
     """Contains the data relative to the invocation request"""
-    integration_request: Optional[IntegrationRequest]
+    integration_request: IntegrationRequest | None
     """Contains the data needed to construct an HTTP request to an Integration"""
-    endpoint_response: Optional[EndpointResponse]
+    endpoint_response: EndpointResponse | None
     """Contains the data returned by an Integration"""
-    invocation_response: Optional[InvocationResponse]
+    invocation_response: InvocationResponse | None
     """Contains the data serialized and to be returned by an invocation"""
 
     def __init__(self, request: Request):

localstack/services/apigateway/next_gen/execute_api/handlers/api_key_validation.py

@@ -1,5 +1,4 @@
 import logging
-from typing import Optional
 
 from localstack.aws.api.apigateway import ApiKey, ApiKeySourceType, RestApi
 from localstack.http import Response
@@ -56,9 +55,7 @@ class ApiKeyValidationHandler(RestApiGatewayHandler):
         LOG.debug("Updating $context.identity.apiKeyId='%s'", validated_key["id"])
         identity["apiKeyId"] = validated_key["id"]
 
-    def validate_api_key(
-        self, api_key_value, context: RestApiInvocationContext
-    ) -> Optional[ApiKey]:
+    def validate_api_key(self, api_key_value, context: RestApiInvocationContext) -> ApiKey | None:
         api_id = context.api_id
         stage = context.stage
         account_id = context.account_id
@@ -95,7 +92,7 @@ class ApiKeyValidationHandler(RestApiGatewayHandler):
 
     def get_request_api_key(
         self, rest_api: RestApi, request: InvocationRequest, identity: ContextVarsIdentity
-    ) -> Optional[str]:
+    ) -> str | None:
         """https://docs.aws.amazon.com/apigateway/latest/developerguide/api-gateway-api-key-source.html
         The source of the API key for metering requests according to a usage plan.
         Valid values are:

localstack/services/apigateway/next_gen/execute_api/handlers/method_request.py

@@ -50,7 +50,11 @@ class MethodRequestHandler(RestApiGatewayHandler):
         # check if there is a validator for this request
         if not (validator := rest_api.validators.get(request_validator_id)):
             # TODO Should we raise an exception instead?
-            LOG.exception("No validator were found with matching id: '%s'", request_validator_id)
+            LOG.error(
+                "No validator were found with matching id: '%s'",
+                request_validator_id,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
+            )
             return
 
         if self.should_validate_request(validator) and (
@@ -87,9 +91,10 @@ class MethodRequestHandler(RestApiGatewayHandler):
         # try to get the resolved model first
         resolved_schema = model_resolver.get_resolved_model()
         if not resolved_schema:
-            LOG.exception(
+            LOG.error(
                 "An exception occurred while trying to validate the request: could not resolve the model '%s'",
                 model_name,
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
             return False
 

localstack/services/apigateway/next_gen/execute_api/handlers/parse.py

@@ -2,7 +2,6 @@ import datetime
 import logging
 import re
 from collections import defaultdict
-from typing import Optional
 from urllib.parse import urlparse
 
 from rolo.request import restore_payload
@@ -178,7 +177,7 @@ class InvocationRequestParser(RestApiGatewayHandler):
         return context_variables
 
     @staticmethod
-    def get_stage_variables(context: RestApiInvocationContext) -> Optional[dict[str, str]]:
+    def get_stage_variables(context: RestApiInvocationContext) -> dict[str, str] | None:
         stage_variables = context.stage_configuration.get("variables")
         if context.is_canary:
             overrides = (

localstack/services/apigateway/next_gen/execute_api/handlers/resource_router.py

@@ -1,7 +1,7 @@
 import logging
+from collections.abc import Iterable
 from functools import cache
 from http import HTTPMethod
-from typing import Iterable
 
 from werkzeug.exceptions import MethodNotAllowed, NotFound
 from werkzeug.routing import Map, MapAdapter, Rule
@@ -85,12 +85,11 @@ class RestAPIResourceRouter:
             rule, args = matcher.match(path, method=request.method, return_rule=True)
         except (MethodNotAllowed, NotFound) as e:
             # MethodNotAllowed (405) exception is raised if a path is matching, but the method does not.
-            # Our router might handle this as a 404, validate with AWS.
+            # AWS handles this and the regular 404 as a '403 MissingAuthTokenError'
             LOG.warning(
                 "API Gateway: No resource or method was found for: %s %s",
                 request.method,
                 path,
-                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
             raise MissingAuthTokenError("Missing Authentication Token") from e