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

localstack/services/apigateway/legacy/context.py

@@ -1,7 +1,7 @@
 import base64
 import json
 from enum import Enum
-from typing import Any, Dict, List, Optional, Union
+from typing import Any
 
 from responses import Response
 
@@ -10,7 +10,7 @@ from localstack.utils.aws.aws_responses import parse_query_string
 from localstack.utils.strings import short_uid, to_str
 
 # type definition for data parameters (i.e., invocation payloads)
-InvocationPayload = Union[Dict, str, bytes]
+InvocationPayload = dict | str | bytes
 
 
 class ApiGatewayVersion(Enum):
@@ -25,15 +25,15 @@ class ApiInvocationContext:
     method: str
     path: str
     data: InvocationPayload
-    headers: Dict[str, str]
+    headers: dict[str, str]
 
     # raw URI (including query string) retired from werkzeug "RAW_URI" environment variable
     raw_uri: str
 
     # invocation context
-    context: Dict[str, Any]
+    context: dict[str, Any]
     # authentication info for this invocation
-    auth_context: Dict[str, Any]
+    auth_context: dict[str, Any]
 
     # target API/resource details extracted from the invocation
     apigw_version: ApiGatewayVersion
@@ -43,24 +43,24 @@ class ApiInvocationContext:
     region_name: str
     # resource path, including any path parameter placeholders (e.g., "/my/path/{id}")
     resource_path: str
-    integration: Dict
-    resource: Dict
+    integration: dict
+    resource: dict
     # Invocation path with query string, e.g., "/my/path?test". Defaults to "path", can be used
     #  to overwrite the actual API path, in case the path format "../_user_request_/.." is used.
     _path_with_query_string: str
 
     # response templates to be applied to the invocation result
-    response_templates: Dict
+    response_templates: dict
 
-    route: Dict
+    route: dict
     connection_id: str
-    path_params: Dict
+    path_params: dict
 
     # response object
     response: Response
 
     # dict of stage variables (mapping names to values)
-    stage_variables: Dict[str, str]
+    stage_variables: dict[str, str]
 
     # websockets route selection
     ws_route: str
@@ -69,12 +69,12 @@ class ApiInvocationContext:
         self,
         method: str,
         path: str,
-        data: Union[str, bytes],
-        headers: Dict[str, str],
+        data: str | bytes,
+        headers: dict[str, str],
         api_id: str = None,
         stage: str = None,
-        context: Dict[str, Any] = None,
-        auth_context: Dict[str, Any] = None,
+        context: dict[str, Any] = None,
+        auth_context: dict[str, Any] = None,
     ):
         self.method = method
         self._path = path
@@ -109,7 +109,7 @@ class ApiInvocationContext:
         self._path = new_path
 
     @property
-    def resource_id(self) -> Optional[str]:
+    def resource_id(self) -> str | None:
         return (self.resource or {}).get("id")
 
     @property
@@ -130,18 +130,18 @@ class ApiInvocationContext:
             new_path = "/" + new_path.lstrip("/")
         self._path_with_query_string = new_path
 
-    def query_params(self) -> Dict[str, str]:
+    def query_params(self) -> dict[str, str]:
         """Extract the query parameters from the target URL or path in this request context."""
         query_string = self.path_with_query_string.partition("?")[2]
         return parse_query_string(query_string)
 
     @property
-    def integration_uri(self) -> Optional[str]:
+    def integration_uri(self) -> str | None:
         integration = self.integration or {}
         return integration.get("uri") or integration.get("integrationUri")
 
     @property
-    def auth_identity(self) -> Optional[Dict]:
+    def auth_identity(self) -> dict | None:
         if isinstance(self.auth_context, dict):
             if self.auth_context.get("identity") is None:
                 self.auth_context["identity"] = {}
@@ -153,7 +153,7 @@ class ApiInvocationContext:
             return self.auth_context.get("authorizer_type") if self.auth_context else None
 
     @property
-    def authorizer_result(self) -> Dict[str, Any]:
+    def authorizer_result(self) -> dict[str, Any]:
         if isinstance(self.auth_context, dict):
             return self.auth_context.get("authorizer") if self.auth_context else {}
 
@@ -165,7 +165,7 @@ class ApiInvocationContext:
         """Whether this is an API Gateway v1 request"""
         return self.apigw_version == ApiGatewayVersion.V1
 
-    def cookies(self) -> Optional[List[str]]:
+    def cookies(self) -> list[str] | None:
         if cookies := self.headers.get("cookie") or "":
             return list(cookies.split(";"))
         return None

localstack/services/apigateway/legacy/helpers.py

@@ -3,8 +3,8 @@ import logging
 import re
 import time
 from collections import defaultdict
-from datetime import datetime, timezone
-from typing import Any, Dict, List, Optional, Tuple, TypedDict, Union
+from datetime import UTC, datetime
+from typing import Any, TypedDict
 from urllib import parse as urlparse
 
 from botocore.utils import InvalidArnException
@@ -37,7 +37,7 @@ PATH_REGEX_TEST_INVOKE_API = r"^\/restapis\/([A-Za-z0-9_\-]+)\/resources\/([A-Za
 
 # regex path pattern for user requests, handles stages like $default
 PATH_REGEX_USER_REQUEST = (
-    r"^/restapis/([A-Za-z0-9_\\-]+)(?:/([A-Za-z0-9\_($|%%24)\\-]+))?/%s/(.*)$" % PATH_USER_REQUEST
+    rf"^/restapis/([A-Za-z0-9_\\-]+)(?:/([A-Za-z0-9\_($|%24)\\-]+))?/{PATH_USER_REQUEST}/(.*)$"
 )
 # URL pattern for invocations
 HOST_REGEX_EXECUTE_API = r"(?:.*://)?([a-zA-Z0-9]+)(?:(-vpce-[^.]+))?\.execute-api\.(.*)"
@@ -90,7 +90,7 @@ class RequestParametersResolver:
 
         :return: IntegrationParameters
         """
-        method_request_params: Dict[str, Any] = self.method_request_dict(context)
+        method_request_params: dict[str, Any] = self.method_request_dict(context)
 
         # requestParameters: {
         #     "integration.request.path.pathParam": "method.request.header.Content-Type"
@@ -128,13 +128,13 @@ class RequestParametersResolver:
 
         return result
 
-    def method_request_dict(self, context: ApiInvocationContext) -> Dict[str, Any]:
+    def method_request_dict(self, context: ApiInvocationContext) -> dict[str, Any]:
         """
         Build a dict with all method request parameters and their values.
         :return: dict with all method request parameters and their values,
         and all keys in lowercase
         """
-        params: Dict[str, str] = {}
+        params: dict[str, str] = {}
 
         # TODO: add support for multi-values headers and multi-values querystring
 
@@ -183,7 +183,7 @@ class RequestParametersResolver:
 
 
 class ResponseParametersResolver:
-    def resolve(self, context: ApiInvocationContext) -> Dict[str, str]:
+    def resolve(self, context: ApiInvocationContext) -> dict[str, str]:
         """
         Resolve integration response parameters into method response parameters.
         Integration response parameters can map header, body,
@@ -191,7 +191,7 @@ class ResponseParametersResolver:
 
         :return: dict with all method response parameters and their values
         """
-        integration_request_params: Dict[str, Any] = self.integration_request_dict(context)
+        integration_request_params: dict[str, Any] = self.integration_request_dict(context)
 
         # "responseParameters" : {
         #     "method.response.header.Location" : "integration.response.body.redirect.url",
@@ -213,7 +213,7 @@ class ResponseParametersResolver:
                 method_parameters[k] = v.replace("'", "")
 
         # build the integration parameters
-        result: Dict[str, str] = {}
+        result: dict[str, str] = {}
         for k, v in method_parameters.items():
             # headers
             if k.startswith("method.response.header."):
@@ -222,8 +222,8 @@ class ResponseParametersResolver:
 
         return result
 
-    def integration_request_dict(self, context: ApiInvocationContext) -> Dict[str, Any]:
-        params: Dict[str, str] = {}
+    def integration_request_dict(self, context: ApiInvocationContext) -> dict[str, Any]:
+        params: dict[str, str] = {}
 
         for k, v in context.headers.items():
             params[f"integration.request.header.{k}"] = v
@@ -293,7 +293,7 @@ def is_test_invoke_method(method, path):
     return method == "POST" and bool(re.match(PATH_REGEX_TEST_INVOKE_API, path))
 
 
-def get_stage_variables(context: ApiInvocationContext) -> Optional[Dict[str, str]]:
+def get_stage_variables(context: ApiInvocationContext) -> dict[str, str] | None:
     if is_test_invoke_method(context.method, context.path):
         return None
 
@@ -316,7 +316,7 @@ def tokenize_path(path):
     return path.lstrip("/").split("/")
 
 
-def extract_path_params(path: str, extracted_path: str) -> Dict[str, str]:
+def extract_path_params(path: str, extracted_path: str) -> dict[str, str]:
     tokenized_extracted_path = tokenize_path(extracted_path)
     # Looks for '{' in the tokenized extracted path
     path_params_list = [(i, v) for i, v in enumerate(tokenized_extracted_path) if "{" in v]
@@ -335,7 +335,7 @@ def extract_path_params(path: str, extracted_path: str) -> Dict[str, str]:
     return path_params
 
 
-def extract_query_string_params(path: str) -> Tuple[str, Dict[str, str]]:
+def extract_query_string_params(path: str) -> tuple[str, dict[str, str]]:
     parsed_path = urlparse.urlparse(path)
     if not path.startswith("//"):
         path = parsed_path.path
@@ -375,12 +375,12 @@ def get_apigateway_path_for_resource(
     path_part = target_resource.get("pathPart", "")
     if path_suffix:
         if path_part:
-            path_suffix = "%s/%s" % (path_part, path_suffix)
+            path_suffix = f"{path_part}/{path_suffix}"
     else:
         path_suffix = path_part
     parent_id = target_resource.get("parentId")
     if not parent_id:
-        return "/%s" % path_suffix
+        return f"/{path_suffix}"
     return get_apigateway_path_for_resource(
         api_id,
         parent_id,
@@ -411,15 +411,15 @@ def get_rest_api_paths(account_id: str, region_name: str, rest_api_id: str):
 #  -method-request.html
 #  https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-routes.html
 def get_resource_for_path(
-    path: str, method: str, path_map: Dict[str, Dict]
-) -> tuple[Optional[str], Optional[dict]]:
+    path: str, method: str, path_map: dict[str, dict]
+) -> tuple[str | None, dict | None]:
     matches = []
     # creates a regex from the input path if there are parameters, e.g /foo/{bar}/baz -> /foo/[
     # ^\]+/baz, otherwise is a direct match.
     for api_path, details in path_map.items():
         api_path_regex = re.sub(r"{[^+]+\+}", r"[^\?#]+", api_path)
         api_path_regex = re.sub(r"{[^}]+}", r"[^/]+", api_path_regex)
-        if re.match(r"^%s$" % api_path_regex, path):
+        if re.match(rf"^{api_path_regex}$", path):
             matches.append((api_path, details))
 
     # if there are no matches, it's not worth to proceed, bail here!
@@ -508,8 +508,7 @@ def connect_api_gateway_to_sqs(gateway_name, stage_name, queue_arn, path, accoun
             "integrations": [
                 {
                     "type": "AWS",
-                    "uri": "arn:%s:apigateway:%s:sqs:path/%s/%s"
-                    % (partition, sqs_region, sqs_account, queue_name),
+                    "uri": f"arn:{partition}:apigateway:{sqs_region}:sqs:path/{sqs_account}/{queue_name}",
                     "requestTemplates": {"application/json": template},
                     "requestParameters": {
                         "integration.request.header.Content-Type": "'application/x-www-form-urlencoded'"
@@ -528,7 +527,7 @@ def connect_api_gateway_to_sqs(gateway_name, stage_name, queue_arn, path, accoun
 
 def get_target_resource_details(
     invocation_context: ApiInvocationContext,
-) -> Tuple[Optional[str], Optional[dict]]:
+) -> tuple[str | None, dict | None]:
     """Look up and return the API GW resource (path pattern + resource dict) for the given invocation context."""
     path_map = get_rest_api_paths(
         account_id=invocation_context.account_id,
@@ -557,7 +556,7 @@ def get_target_resource_details(
         return None, None
 
 
-def get_target_resource_method(invocation_context: ApiInvocationContext) -> Optional[Dict]:
+def get_target_resource_method(invocation_context: ApiInvocationContext) -> dict | None:
     """Look up and return the API GW resource method for the given invocation context."""
     _, resource = get_target_resource_details(invocation_context)
     if not resource:
@@ -614,7 +613,7 @@ def get_event_request_context(invocation_context: ApiInvocationContext):
         },
         "httpMethod": method,
         "protocol": "HTTP/1.1",
-        "requestTime": datetime.now(timezone.utc).strftime(REQUEST_TIME_DATE_FORMAT),
+        "requestTime": datetime.now(UTC).strftime(REQUEST_TIME_DATE_FORMAT),
         "requestTimeEpoch": int(time.time() * 1000),
         "authorizer": {},
     }
@@ -660,11 +659,11 @@ def set_api_id_stage_invocation_path(
     if path_match:
         api_id = path_match.group(1)
         stage = path_match.group(2)
-        relative_path_w_query_params = "/%s" % path_match.group(3)
+        relative_path_w_query_params = f"/{path_match.group(3)}"
     elif host_match:
         api_id = extract_api_id_from_hostname_in_url(host_header)
         stage = path.strip("/").split("/")[0]
-        relative_path_w_query_params = "/%s" % path.lstrip("/").partition("/")[2]
+        relative_path_w_query_params = "/{}".format(path.lstrip("/").partition("/")[2])
     elif test_invoke_match:
         stage = invocation_context.stage
         api_id = invocation_context.api_id
@@ -681,7 +680,7 @@ def set_api_id_stage_invocation_path(
     return invocation_context
 
 
-def get_api_account_id_and_region(api_id: str) -> Tuple[Optional[str], Optional[str]]:
+def get_api_account_id_and_region(api_id: str) -> tuple[str | None, str | None]:
     """Return the region name for the given REST API ID"""
     for account_id, account in apigateway_backends.items():
         for region_name, region in account.items():
@@ -698,7 +697,7 @@ def extract_api_id_from_hostname_in_url(hostname: str) -> str:
     return match.group(1)
 
 
-def multi_value_dict_for_list(elements: Union[List, Dict]) -> Dict:
+def multi_value_dict_for_list(elements: list | dict) -> dict:
     temp_mv_dict = defaultdict(list)
     for key in elements:
         if isinstance(key, (list, tuple)):

localstack/services/apigateway/legacy/integration.py

@@ -5,7 +5,7 @@ import re
 from abc import ABC, abstractmethod
 from functools import lru_cache
 from http import HTTPMethod, HTTPStatus
-from typing import Any, Dict
+from typing import Any
 from urllib.parse import urljoin
 
 import requests
@@ -91,7 +91,7 @@ class BackendIntegration(ABC):
 
     @classmethod
     def apply_request_parameters(
-        cls, integration_params: IntegrationParameters, headers: Dict[str, Any]
+        cls, integration_params: IntegrationParameters, headers: dict[str, Any]
     ):
         for k, v in integration_params.get("headers").items():
             headers.update({k: v})
@@ -569,7 +569,7 @@ class KinesisIntegration(BackendIntegration):
         return invocation_context.response
 
     @classmethod
-    def _validate_required_params(cls, request_parameters: Dict[str, Any]) -> None:
+    def _validate_required_params(cls, request_parameters: dict[str, Any]) -> None:
         if not request_parameters:
             raise BadRequestException("Missing required parameters")
         # https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-aws-services-reference.html#Kinesis-PutRecord
@@ -588,7 +588,7 @@ class KinesisIntegration(BackendIntegration):
 
     def _create_request_parameters(
         self, invocation_context: ApiInvocationContext
-    ) -> Dict[str, Any]:
+    ) -> dict[str, Any]:
         request_parameters = invocation_context.integration.get("requestParameters", {})
         self._validate_required_params(request_parameters)
 
@@ -756,7 +756,7 @@ class S3Integration(BackendIntegration):
 
 class HTTPIntegration(BackendIntegration):
     @staticmethod
-    def _set_http_apigw_headers(headers: Dict[str, Any], invocation_context: ApiInvocationContext):
+    def _set_http_apigw_headers(headers: dict[str, Any], invocation_context: ApiInvocationContext):
         del headers["host"]
         headers["x-amzn-apigateway-api-id"] = invocation_context.api_id
         return headers
@@ -783,7 +783,7 @@ class HTTPIntegration(BackendIntegration):
             instances = client.list_instances(ServiceId=service_id)["Instances"]
             instance = (instances or [None])[0]
             if instance and instance.get("Id"):
-                uri = "http://%s/%s" % (instance["Id"], invocation_path.lstrip("/"))
+                uri = "http://{}/{}".format(instance["Id"], invocation_path.lstrip("/"))
 
         # apply custom request template
         invocation_context.context = get_event_request_context(invocation_context)
@@ -902,7 +902,7 @@ class SNSIntegration(BackendIntegration):
 
 class StepFunctionIntegration(BackendIntegration):
     @classmethod
-    def _validate_required_params(cls, request_parameters: Dict[str, Any]) -> None:
+    def _validate_required_params(cls, request_parameters: dict[str, Any]) -> None:
         if not request_parameters:
             raise BadRequestException("Missing required parameters")
         # stateMachineArn and input are required
@@ -977,8 +977,9 @@ class StepFunctionIntegration(BackendIntegration):
                     headers={"Content-Type": APPLICATION_JSON},
                     data=json.dumps(
                         {
-                            "message": "StepFunctions execution %s failed with status '%s'"
-                            % (result["executionArn"], result_status)
+                            "message": "StepFunctions execution {} failed with status '{}'".format(
+                                result["executionArn"], result_status
+                            )
                         }
                     ),
                 )
@@ -1065,7 +1066,7 @@ class MockIntegration(BackendIntegration):
 
 # TODO: remove once we migrate all usages to `apply_request_parameters` on BackendIntegration
 def apply_request_parameters(
-    uri: str, integration: Dict[str, Any], path_params: Dict[str, str], query_params: Dict[str, str]
+    uri: str, integration: dict[str, Any], path_params: dict[str, str], query_params: dict[str, str]
 ):
     request_parameters = integration.get("requestParameters")
     uri = uri or integration.get("uri") or integration.get("integrationUri") or ""

localstack/services/apigateway/legacy/invocations.py

@@ -142,8 +142,9 @@ class RequestValidator:
         # try to get the resolved model first
         resolved_schema = model_resolver.get_resolved_model()
         if not resolved_schema:
-            LOG.exception(
-                "An exception occurred while trying to validate the request: could not find the model"
+            LOG.error(
+                "An exception occurred while trying to validate the request: could not find the model",
+                exc_info=LOG.isEnabledFor(logging.DEBUG),
             )
             return False
 
@@ -279,7 +280,7 @@ def invoke_rest_api(invocation_context: ApiInvocationContext):
 
     extracted_path, resource = get_target_resource_details(invocation_context)
     if not resource:
-        return make_error_response("Unable to find path %s" % invocation_context.path, 404)
+        return make_error_response(f"Unable to find path {invocation_context.path}", 404)
 
     # validate request
     validator = RequestValidator(invocation_context)
@@ -306,7 +307,7 @@ def invoke_rest_api(invocation_context: ApiInvocationContext):
             # default to returning CORS headers if this is an OPTIONS request
             return get_cors_response(headers)
         return make_error_response(
-            "Unable to find integration for: %s %s (%s)" % (method, invocation_path, raw_path),
+            f"Unable to find integration for: {method} {invocation_path} ({raw_path})",
             404,
         )
 
@@ -334,7 +335,7 @@ def invoke_rest_api_integration(invocation_context: ApiInvocationContext):
         return e.to_response()
     except Exception as e:
         msg = f"Error invoking integration for API Gateway ID '{invocation_context.api_id}': {e}"
-        LOG.exception(msg)
+        LOG.error(msg, exc_info=LOG.isEnabledFor(logging.DEBUG))
         return make_error_response(msg, 400)