localstack-core 4.7.1.dev22__py3-none-any.whl → 4.7.1.dev24__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
@@ -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
@@ -411,8 +411,8 @@ 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.
@@ -528,7 +528,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 +557,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 +614,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": {},
     }
@@ -681,7 +681,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 +698,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
@@ -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
@@ -1065,7 +1065,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/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
@@ -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/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

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

@@ -1,6 +1,6 @@
 import logging
 from collections import defaultdict
-from typing import Iterable
+from collections.abc import Iterable
 
 from werkzeug.datastructures.headers import Headers
 

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

@@ -4,7 +4,7 @@ import random
 import re
 import time
 from secrets import token_hex
-from typing import Type, TypedDict
+from typing import TypedDict
 
 from moto.apigateway.models import RestAPI as MotoRestAPI
 
@@ -115,7 +115,7 @@ def get_lambda_function_arn_from_invocation_uri(uri: str) -> str:
     return uri.split("functions/")[1].removesuffix("/invocations")
 
 
-def validate_sub_dict_of_typed_dict(typed_dict: Type[TypedDict], obj: dict) -> bool:
+def validate_sub_dict_of_typed_dict(typed_dict: type[TypedDict], obj: dict) -> bool:
     """
     Validate that the object is a subset off the keys of a given `TypedDict`.
     :param typed_dict: the `TypedDict` blueprint