localstack-core 4.7.1.dev49__py3-none-any.whl → 4.10.1.dev12__py3-none-any.whl

localstack/runtime/patches.py

@@ -38,14 +38,14 @@ def patch_urllib3_connection_pool(**constructor_kwargs):
         class MyHTTPSConnectionPool(connectionpool.HTTPSConnectionPool):
             def __init__(self, *args, **kwargs):
                 kwargs.update(constructor_kwargs)
-                super(MyHTTPSConnectionPool, self).__init__(*args, **kwargs)
+                super().__init__(*args, **kwargs)
 
         poolmanager.pool_classes_by_scheme["https"] = MyHTTPSConnectionPool
 
         class MyHTTPConnectionPool(connectionpool.HTTPConnectionPool):
             def __init__(self, *args, **kwargs):
                 kwargs.update(constructor_kwargs)
-                super(MyHTTPConnectionPool, self).__init__(*args, **kwargs)
+                super().__init__(*args, **kwargs)
 
         poolmanager.pool_classes_by_scheme["http"] = MyHTTPConnectionPool
     except Exception:

localstack/services/apigateway/helpers.py

@@ -367,10 +367,7 @@ def resolve_references(data: dict, rest_api_id, allow_recursive=True) -> dict:
 
 def path_based_url(api_id: str, stage_name: str, path: str) -> str:
     """Return URL for inbound API gateway for given API ID, stage name, and path"""
-    pattern = "%s/restapis/{api_id}/{stage_name}/%s{path}" % (
-        config.external_service_url(),
-        PATH_USER_REQUEST,
-    )
+    pattern = f"{config.external_service_url()}/restapis/{{api_id}}/{{stage_name}}/{PATH_USER_REQUEST}{{path}}"
     return pattern.format(api_id=api_id, stage_name=stage_name, path=path)
 
 

localstack/services/apigateway/legacy/helpers.py

@@ -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\.(.*)"
@@ -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,
@@ -419,7 +419,7 @@ def get_resource_for_path(
     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'"
@@ -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

localstack/services/apigateway/legacy/integration.py

@@ -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)
@@ -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
+                            )
                         }
                     ),
                 )

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)
 
 

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/templates.py

@@ -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)

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/resource_router.py

@@ -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
 

localstack/services/apigateway/next_gen/execute_api/integrations/aws.py

@@ -211,6 +211,9 @@ class RestApiAwsIntegration(RestApiIntegration):
             action = parsed_uri["path"]
 
             if target := self.get_action_service_target(service_name, action):
+                # TODO: properly implement the auto-`Content-Type` headers depending on the service protocol
+                #  e.g. `x-amz-json-1.0` for DynamoDB
+                #  this is needed to properly support multi-protocol
                 headers["X-Amz-Target"] = target
 
             query_params["Action"] = action

localstack/services/apigateway/next_gen/execute_api/integrations/http.py

@@ -8,7 +8,7 @@ from werkzeug.datastructures import Headers
 from localstack.aws.api.apigateway import Integration
 
 from ..context import EndpointResponse, IntegrationRequest, RestApiInvocationContext
-from ..gateway_response import ApiConfigurationError, IntegrationFailureError
+from ..gateway_response import ApiConfigurationError, IntegrationFailureError, InternalServerError
 from ..header_utils import build_multi_value_headers
 from .core import RestApiIntegration
 
@@ -72,7 +72,7 @@ class RestApiHttpIntegration(BaseRestApiHttpIntegration):
         except (requests.exceptions.InvalidURL, requests.exceptions.InvalidSchema) as e:
             LOG.warning("Execution failed due to configuration error: Invalid endpoint address")
             LOG.debug("The URI specified for the HTTP/HTTP_PROXY integration is invalid: %s", uri)
-            raise ApiConfigurationError("Internal server error") from e
+            raise InternalServerError("Internal server error") from e
 
         except (requests.exceptions.Timeout, requests.exceptions.SSLError) as e:
             # TODO make the exception catching more fine grained
@@ -127,7 +127,7 @@ class RestApiHttpProxyIntegration(BaseRestApiHttpIntegration):
         except (requests.exceptions.InvalidURL, requests.exceptions.InvalidSchema) as e:
             LOG.warning("Execution failed due to configuration error: Invalid endpoint address")
             LOG.debug("The URI specified for the HTTP/HTTP_PROXY integration is invalid: %s", uri)
-            raise ApiConfigurationError("Internal server error") from e
+            raise InternalServerError("Internal server error") from e
 
         except (requests.exceptions.Timeout, requests.exceptions.SSLError):
             # TODO make the exception catching more fine grained

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

@@ -109,7 +109,7 @@ class VTLJsonList(list):
     """
 
     def __init__(self, *args):
-        super(VTLJsonList, self).__init__(*args)
+        super().__init__(*args)
         for idx, item in enumerate(self):
             self[idx] = cast_to_vtl_json_object(item)
 
@@ -138,7 +138,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)