airbyte-cdk 0.72.1__py3-none-any.whl → 6.13.1.dev4106__py3-none-any.whl

airbyte_cdk/sql/types.py

@@ -0,0 +1,160 @@
+# noqa: A005  # Allow shadowing the built-in 'types' module
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+
+"""Type conversion methods for SQL Caches."""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+import sqlalchemy
+
+# Compare to documentation here: https://docs.airbyte.com/understanding-airbyte/supported-data-types
+CONVERSION_MAP = {
+    "string": sqlalchemy.types.VARCHAR,
+    "integer": sqlalchemy.types.BIGINT,
+    "number": sqlalchemy.types.DECIMAL(38, 9),
+    "boolean": sqlalchemy.types.BOOLEAN,
+    "date": sqlalchemy.types.DATE,
+    "timestamp_with_timezone": sqlalchemy.types.TIMESTAMP,
+    "timestamp_without_timezone": sqlalchemy.types.TIMESTAMP,
+    "time_with_timezone": sqlalchemy.types.TIME,
+    "time_without_timezone": sqlalchemy.types.TIME,
+    # Technically 'object' and 'array' as JSON Schema types, not airbyte types.
+    # We include them here for completeness.
+    "object": sqlalchemy.types.JSON,
+    "array": sqlalchemy.types.JSON,
+    "vector_array": sqlalchemy.types.ARRAY,
+}
+
+
+class SQLTypeConversionError(Exception):
+    """An exception to be raised when a type conversion fails."""
+
+
+def _get_airbyte_type(  # noqa: PLR0911  # Too many return statements
+    json_schema_property_def: dict[str, str | dict[str, Any] | list[Any]],
+) -> tuple[str, str | None]:
+    """Get the airbyte type and subtype from a JSON schema property definition.
+
+    Subtype is only used for array types. Otherwise, subtype will return None.
+    """
+    airbyte_type = cast(str, json_schema_property_def.get("airbyte_type", None))
+    if airbyte_type:
+        return airbyte_type, None
+
+    json_schema_type = json_schema_property_def.get("type", None)
+    json_schema_format = json_schema_property_def.get("format", None)
+
+    # if json_schema_type is an array of two strings with one of them being null, pick the other one
+    # this strategy is often used by connectors to indicate a field might not be set all the time
+    if isinstance(json_schema_type, list):
+        non_null_types = [t for t in json_schema_type if t != "null"]
+        if len(non_null_types) == 1:
+            json_schema_type = non_null_types[0]
+
+    if json_schema_type == "string":
+        if json_schema_format == "date":
+            return "date", None
+
+        if json_schema_format == "date-time":
+            return "timestamp_with_timezone", None
+
+        if json_schema_format == "time":
+            return "time_without_timezone", None
+
+    if isinstance(json_schema_type, str) and json_schema_type in {
+        "string",
+        "number",
+        "boolean",
+        "integer",
+    }:
+        return json_schema_type, None
+
+    if json_schema_type == "object":
+        return "object", None
+
+    if json_schema_type == "array":
+        items_def = json_schema_property_def.get("items", None)
+        if isinstance(items_def, dict):
+            try:
+                subtype, _ = _get_airbyte_type(items_def)
+            except SQLTypeConversionError:
+                # We have enough information, so we can ignore parsing errors on subtype.
+                subtype = None
+
+            return "array", subtype
+
+        return "array", None
+
+    if json_schema_type == "vector_array":
+        return "vector_array", "Float"
+
+    err_msg = f"Could not determine airbyte type from JSON schema type: {json_schema_property_def}"
+    raise SQLTypeConversionError(err_msg)
+
+
+class SQLTypeConverter:
+    """A base class to perform type conversions."""
+
+    def __init__(
+        self,
+        conversion_map: dict[str, Any] | None = None,
+    ) -> None:
+        """Initialize the type converter."""
+        self.conversion_map = conversion_map or CONVERSION_MAP
+
+    @classmethod
+    def get_string_type(cls) -> sqlalchemy.types.TypeEngine[str]:
+        """Get the type to use for string data."""
+        return sqlalchemy.types.VARCHAR()
+
+    @classmethod
+    def get_failover_type(cls) -> sqlalchemy.types.TypeEngine[str]:
+        """Get the 'last resort' type to use if no other type is found."""
+        return cls.get_string_type()
+
+    @classmethod
+    def get_json_type(cls) -> sqlalchemy.types.TypeEngine[Any]:
+        """Get the type to use for nested JSON data."""
+        return sqlalchemy.types.JSON()
+
+    def to_sql_type(  # noqa: PLR0911  # Too many return statements
+        self,
+        json_schema_property_def: dict[str, str | dict[str, Any] | list[Any]],
+    ) -> Any:
+        """Convert a value to a SQL type."""
+        try:
+            airbyte_type, _ = _get_airbyte_type(json_schema_property_def)
+            # to-do - is there a better way to check the following
+            if airbyte_type == "vector_array":
+                return sqlalchemy.types.ARRAY(sqlalchemy.types.Float())
+            sql_type = self.conversion_map[airbyte_type]
+        except SQLTypeConversionError:
+            print(f"Could not determine airbyte type from JSON schema: {json_schema_property_def}")
+        except KeyError:
+            print(f"Could not find SQL type for airbyte type: {airbyte_type}")
+        else:
+            # No exceptions were raised, so we can return the SQL type.
+            if isinstance(sql_type, type):
+                # This is a class. Call its constructor.
+                sql_type = sql_type()
+
+            return sql_type
+
+        json_schema_type = json_schema_property_def.get("type", None)
+        json_schema_format = json_schema_property_def.get("format", None)
+
+        if json_schema_type == "string" and json_schema_format == "date":
+            return sqlalchemy.types.DATE()
+
+        if json_schema_type == "string" and json_schema_format == "date-time":
+            return sqlalchemy.types.TIMESTAMP()
+
+        if json_schema_type == "array":
+            return sqlalchemy.types.JSON()
+
+        if json_schema_type == "object":
+            return sqlalchemy.types.JSON()
+
+        return self.get_failover_type()

airbyte_cdk/test/catalog_builder.py

@@ -1,29 +1,81 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 
-from typing import Any, Dict, List
+from typing import Any, Dict, List, Union, overload
 
-from airbyte_protocol.models import ConfiguredAirbyteCatalog, SyncMode
+from airbyte_cdk.models import (
+    ConfiguredAirbyteCatalog,
+    ConfiguredAirbyteStream,
+    ConfiguredAirbyteStreamSerializer,
+    SyncMode,
+)
+
+
+class ConfiguredAirbyteStreamBuilder:
+    def __init__(self) -> None:
+        self._stream: Dict[str, Any] = {
+            "stream": {
+                "name": "any name",
+                "json_schema": {},
+                "supported_sync_modes": ["full_refresh", "incremental"],
+                "source_defined_primary_key": [["id"]],
+            },
+            "primary_key": [["id"]],
+            "sync_mode": "full_refresh",
+            "destination_sync_mode": "overwrite",
+        }
+
+    def with_name(self, name: str) -> "ConfiguredAirbyteStreamBuilder":
+        self._stream["stream"]["name"] = name  # type: ignore  # we assume that self._stream["stream"] is a Dict[str, Any]
+        return self
+
+    def with_sync_mode(self, sync_mode: SyncMode) -> "ConfiguredAirbyteStreamBuilder":
+        self._stream["sync_mode"] = sync_mode.name
+        return self
+
+    def with_primary_key(self, pk: List[List[str]]) -> "ConfiguredAirbyteStreamBuilder":
+        self._stream["primary_key"] = pk
+        self._stream["stream"]["source_defined_primary_key"] = pk  # type: ignore  # we assume that self._stream["stream"] is a Dict[str, Any]
+        return self
+
+    def with_json_schema(self, json_schema: Dict[str, Any]) -> "ConfiguredAirbyteStreamBuilder":
+        self._stream["stream"]["json_schema"] = json_schema
+        return self
+
+    def build(self) -> ConfiguredAirbyteStream:
+        return ConfiguredAirbyteStreamSerializer.load(self._stream)
 
 
 class CatalogBuilder:
     def __init__(self) -> None:
-        self._streams: List[Dict[str, Any]] = []
-
-    def with_stream(self, name: str, sync_mode: SyncMode) -> "CatalogBuilder":
-        self._streams.append(
-            {
-                "stream": {
-                    "name": name,
-                    "json_schema": {},
-                    "supported_sync_modes": ["full_refresh", "incremental"],
-                    "source_defined_primary_key": [["id"]],
-                },
-                "primary_key": [["id"]],
-                "sync_mode": sync_mode.name,
-                "destination_sync_mode": "overwrite",
-            }
+        self._streams: List[ConfiguredAirbyteStreamBuilder] = []
+
+    @overload
+    def with_stream(self, name: ConfiguredAirbyteStreamBuilder) -> "CatalogBuilder": ...
+
+    @overload
+    def with_stream(self, name: str, sync_mode: SyncMode) -> "CatalogBuilder": ...
+
+    def with_stream(
+        self,
+        name: Union[str, ConfiguredAirbyteStreamBuilder],
+        sync_mode: Union[SyncMode, None] = None,
+    ) -> "CatalogBuilder":
+        # As we are introducing a fully fledge ConfiguredAirbyteStreamBuilder, we would like to deprecate the previous interface
+        # with_stream(str, SyncMode)
+
+        # to avoid a breaking change, `name` needs to stay in the API but this can be either a name or a builder
+        name_or_builder = name
+        builder = (
+            name_or_builder
+            if isinstance(name_or_builder, ConfiguredAirbyteStreamBuilder)
+            else ConfiguredAirbyteStreamBuilder()
+            .with_name(name_or_builder)
+            .with_sync_mode(sync_mode)
         )
+        self._streams.append(builder)
         return self
 
     def build(self) -> ConfiguredAirbyteCatalog:
-        return ConfiguredAirbyteCatalog.parse_obj({"streams": self._streams})
+        return ConfiguredAirbyteCatalog(
+            streams=list(map(lambda builder: builder.build(), self._streams))
+        )

airbyte_cdk/test/entrypoint_wrapper.py

@@ -16,46 +16,59 @@ than that, there are integrations point that are annoying to integrate with usin
 
 import json
 import logging
+import re
 import tempfile
 import traceback
 from io import StringIO
 from pathlib import Path
 from typing import Any, List, Mapping, Optional, Union
 
+import orjson
+from pydantic import ValidationError as V2ValidationError
+from serpyco_rs import SchemaValidationError
+
 from airbyte_cdk.entrypoint import AirbyteEntrypoint
 from airbyte_cdk.exception_handler import assemble_uncaught_exception
 from airbyte_cdk.logger import AirbyteLogFormatter
-from airbyte_cdk.sources import Source
-from airbyte_protocol.models import (
+from airbyte_cdk.models import (
     AirbyteLogMessage,
     AirbyteMessage,
+    AirbyteMessageSerializer,
     AirbyteStateMessage,
+    AirbyteStateMessageSerializer,
     AirbyteStreamStatus,
     ConfiguredAirbyteCatalog,
+    ConfiguredAirbyteCatalogSerializer,
     Level,
     TraceType,
     Type,
 )
-from pydantic.error_wrappers import ValidationError
+from airbyte_cdk.sources import Source
 
 
 class EntrypointOutput:
     def __init__(self, messages: List[str], uncaught_exception: Optional[BaseException] = None):
         try:
             self._messages = [self._parse_message(message) for message in messages]
-        except ValidationError as exception:
+        except V2ValidationError as exception:
             raise ValueError("All messages are expected to be AirbyteMessage") from exception
 
         if uncaught_exception:
-            self._messages.append(assemble_uncaught_exception(type(uncaught_exception), uncaught_exception).as_airbyte_message())
+            self._messages.append(
+                assemble_uncaught_exception(
+                    type(uncaught_exception), uncaught_exception
+                ).as_airbyte_message()
+            )
 
     @staticmethod
     def _parse_message(message: str) -> AirbyteMessage:
         try:
-            return AirbyteMessage.parse_obj(json.loads(message))
-        except (json.JSONDecodeError, ValidationError):
+            return AirbyteMessageSerializer.load(orjson.loads(message))
+        except (orjson.JSONDecodeError, SchemaValidationError):
             # The platform assumes that logs that are not of AirbyteMessage format are log messages
-            return AirbyteMessage(type=Type.LOG, log=AirbyteLogMessage(level=Level.INFO, message=message))
+            return AirbyteMessage(
+                type=Type.LOG, log=AirbyteLogMessage(level=Level.INFO, message=message)
+            )
 
     @property
     def records_and_state_messages(self) -> List[AirbyteMessage]:
@@ -74,7 +87,7 @@ class EntrypointOutput:
         state_messages = self._get_message_by_types([Type.STATE])
         if not state_messages:
             raise ValueError("Can't provide most recent state as there are no state messages")
-        return state_messages[-1].state.stream
+        return state_messages[-1].state.stream  # type: ignore[union-attr] # state has `stream`
 
     @property
     def logs(self) -> List[AirbyteMessage]:
@@ -92,11 +105,18 @@ class EntrypointOutput:
     def errors(self) -> List[AirbyteMessage]:
         return self._get_trace_message_by_trace_type(TraceType.ERROR)
 
+    @property
+    def catalog(self) -> AirbyteMessage:
+        catalog = self._get_message_by_types([Type.CATALOG])
+        if len(catalog) != 1:
+            raise ValueError(f"Expected exactly one catalog but got {len(catalog)}")
+        return catalog[0]
+
     def get_stream_statuses(self, stream_name: str) -> List[AirbyteStreamStatus]:
         status_messages = map(
-            lambda message: message.trace.stream_status.status,
+            lambda message: message.trace.stream_status.status,  # type: ignore
             filter(
-                lambda message: message.trace.stream_status.stream_descriptor.name == stream_name,
+                lambda message: message.trace.stream_status.stream_descriptor.name == stream_name,  # type: ignore # callable; trace has `stream_status`
                 self._get_trace_message_by_trace_type(TraceType.STREAM_STATUS),
             ),
         )
@@ -106,7 +126,77 @@ class EntrypointOutput:
         return [message for message in self._messages if message.type in message_types]
 
     def _get_trace_message_by_trace_type(self, trace_type: TraceType) -> List[AirbyteMessage]:
-        return [message for message in self._get_message_by_types([Type.TRACE]) if message.trace.type == trace_type]
+        return [
+            message
+            for message in self._get_message_by_types([Type.TRACE])
+            if message.trace.type == trace_type  # type: ignore[union-attr] # trace has `type`
+        ]
+
+    def is_in_logs(self, pattern: str) -> bool:
+        """Check if any log message case-insensitive matches the pattern."""
+        return any(
+            re.search(
+                pattern,
+                entry.log.message,  # type: ignore[union-attr] # log has `message`
+                flags=re.IGNORECASE,
+            )
+            for entry in self.logs
+        )
+
+    def is_not_in_logs(self, pattern: str) -> bool:
+        """Check if no log message matches the case-insensitive pattern."""
+        return not self.is_in_logs(pattern)
+
+
+def _run_command(
+    source: Source, args: List[str], expecting_exception: bool = False
+) -> EntrypointOutput:
+    log_capture_buffer = StringIO()
+    stream_handler = logging.StreamHandler(log_capture_buffer)
+    stream_handler.setLevel(logging.INFO)
+    stream_handler.setFormatter(AirbyteLogFormatter())
+    parent_logger = logging.getLogger("")
+    parent_logger.addHandler(stream_handler)
+
+    parsed_args = AirbyteEntrypoint.parse_args(args)
+
+    source_entrypoint = AirbyteEntrypoint(source)
+    messages = []
+    uncaught_exception = None
+    try:
+        for message in source_entrypoint.run(parsed_args):
+            messages.append(message)
+    except Exception as exception:
+        if not expecting_exception:
+            print("Printing unexpected error from entrypoint_wrapper")
+            print("".join(traceback.format_exception(None, exception, exception.__traceback__)))
+        uncaught_exception = exception
+
+    captured_logs = log_capture_buffer.getvalue().split("\n")[:-1]
+
+    parent_logger.removeHandler(stream_handler)
+
+    return EntrypointOutput(messages + captured_logs, uncaught_exception)
+
+
+def discover(
+    source: Source,
+    config: Mapping[str, Any],
+    expecting_exception: bool = False,
+) -> EntrypointOutput:
+    """
+    config must be json serializable
+    :param expecting_exception: By default if there is an uncaught exception, the exception will be printed out. If this is expected, please
+        provide expecting_exception=True so that the test output logs are cleaner
+    """
+
+    with tempfile.TemporaryDirectory() as tmp_directory:
+        tmp_directory_path = Path(tmp_directory)
+        config_file = make_file(tmp_directory_path / "config.json", config)
+
+        return _run_command(
+            source, ["discover", "--config", config_file, "--debug"], expecting_exception
+        )
 
 
 def read(
@@ -122,52 +212,37 @@ def read(
     :param expecting_exception: By default if there is an uncaught exception, the exception will be printed out. If this is expected, please
         provide expecting_exception=True so that the test output logs are cleaner
     """
-    log_capture_buffer = StringIO()
-    stream_handler = logging.StreamHandler(log_capture_buffer)
-    stream_handler.setLevel(logging.INFO)
-    stream_handler.setFormatter(AirbyteLogFormatter())
-    parent_logger = logging.getLogger("")
-    parent_logger.addHandler(stream_handler)
-
     with tempfile.TemporaryDirectory() as tmp_directory:
         tmp_directory_path = Path(tmp_directory)
+        config_file = make_file(tmp_directory_path / "config.json", config)
+        catalog_file = make_file(
+            tmp_directory_path / "catalog.json",
+            orjson.dumps(ConfiguredAirbyteCatalogSerializer.dump(catalog)).decode(),
+        )
         args = [
             "read",
             "--config",
-            make_file(tmp_directory_path / "config.json", config),
+            config_file,
             "--catalog",
-            make_file(tmp_directory_path / "catalog.json", catalog.json()),
+            catalog_file,
         ]
         if state is not None:
             args.extend(
                 [
                     "--state",
-                    make_file(tmp_directory_path / "state.json", f"[{','.join([stream_state.json() for stream_state in state])}]"),
+                    make_file(
+                        tmp_directory_path / "state.json",
+                        f"[{','.join([orjson.dumps(AirbyteStateMessageSerializer.dump(stream_state)).decode() for stream_state in state])}]",
+                    ),
                 ]
             )
-        args.append("--debug")
-        source_entrypoint = AirbyteEntrypoint(source)
-        parsed_args = source_entrypoint.parse_args(args)
-
-        messages = []
-        uncaught_exception = None
-        try:
-            for message in source_entrypoint.run(parsed_args):
-                messages.append(message)
-        except Exception as exception:
-            if not expecting_exception:
-                print("Printing unexpected error from entrypoint_wrapper")
-                print("".join(traceback.format_exception(None, exception, exception.__traceback__)))
-            uncaught_exception = exception
-
-        captured_logs = log_capture_buffer.getvalue().split("\n")[:-1]
-
-        parent_logger.removeHandler(stream_handler)
 
-        return EntrypointOutput(messages + captured_logs, uncaught_exception)
+        return _run_command(source, args, expecting_exception)
 
 
-def make_file(path: Path, file_contents: Optional[Union[str, Mapping[str, Any], List[Mapping[str, Any]]]]) -> str:
+def make_file(
+    path: Path, file_contents: Optional[Union[str, Mapping[str, Any], List[Mapping[str, Any]]]]
+) -> str:
     if isinstance(file_contents, str):
         path.write_text(file_contents)
     else:

airbyte_cdk/test/mock_http/__init__.py

@@ -1,6 +1,6 @@
 from airbyte_cdk.test.mock_http.matcher import HttpRequestMatcher
+from airbyte_cdk.test.mock_http.mocker import HttpMocker
 from airbyte_cdk.test.mock_http.request import HttpRequest
 from airbyte_cdk.test.mock_http.response import HttpResponse
-from airbyte_cdk.test.mock_http.mocker import HttpMocker
 
 __all__ = ["HttpMocker", "HttpRequest", "HttpRequestMatcher", "HttpResponse"]

airbyte_cdk/test/mock_http/matcher.py

@@ -1,4 +1,5 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+from typing import Any
 
 from airbyte_cdk.test.mock_http.request import HttpRequest
 
@@ -33,3 +34,8 @@ class HttpRequestMatcher:
             f"minimum_number_of_expected_match={self._minimum_number_of_expected_match}, "
             f"actual_number_of_matches={self._actual_number_of_matches})"
         )
+
+    def __eq__(self, other: Any) -> bool:
+        if isinstance(other, HttpRequestMatcher):
+            return self._request_to_match == other._request_to_match
+        return False

airbyte_cdk/test/mock_http/mocker.py

@@ -7,12 +7,17 @@ from types import TracebackType
 from typing import Callable, List, Optional, Union
 
 import requests_mock
-from airbyte_cdk.test.mock_http import HttpRequest, HttpRequestMatcher, HttpResponse
+
+from airbyte_cdk.test.mock_http.matcher import HttpRequestMatcher
+from airbyte_cdk.test.mock_http.request import HttpRequest
+from airbyte_cdk.test.mock_http.response import HttpResponse
 
 
 class SupportedHttpMethods(str, Enum):
     GET = "get"
+    PATCH = "patch"
     POST = "post"
+    DELETE = "delete"
 
 
 class HttpMocker(contextlib.ContextDecorator):
@@ -40,7 +45,12 @@ class HttpMocker(contextlib.ContextDecorator):
         self._mocker.__enter__()
         return self
 
-    def __exit__(self, exc_type: Optional[BaseException], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]) -> None:
+    def __exit__(
+        self,
+        exc_type: Optional[BaseException],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[TracebackType],
+    ) -> None:
         self._mocker.__exit__(exc_type, exc_val, exc_tb)
 
     def _validate_all_matchers_called(self) -> None:
@@ -49,43 +59,74 @@ class HttpMocker(contextlib.ContextDecorator):
                 raise ValueError(f"Invalid number of matches for `{matcher}`")
 
     def _mock_request_method(
-        self, method: SupportedHttpMethods, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+        self,
+        method: SupportedHttpMethods,
+        request: HttpRequest,
+        responses: Union[HttpResponse, List[HttpResponse]],
     ) -> None:
         if isinstance(responses, HttpResponse):
             responses = [responses]
 
         matcher = HttpRequestMatcher(request, len(responses))
+        if matcher in self._matchers:
+            raise ValueError(f"Request {matcher.request} already mocked")
         self._matchers.append(matcher)
 
         getattr(self._mocker, method)(
             requests_mock.ANY,
             additional_matcher=self._matches_wrapper(matcher),
             response_list=[
-                {"text": response.body, "status_code": response.status_code, "headers": response.headers} for response in responses
+                {
+                    "text": response.body,
+                    "status_code": response.status_code,
+                    "headers": response.headers,
+                }
+                for response in responses
             ],
         )
 
     def get(self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]) -> None:
         self._mock_request_method(SupportedHttpMethods.GET, request, responses)
 
-    def post(self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]) -> None:
+    def patch(
+        self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+    ) -> None:
+        self._mock_request_method(SupportedHttpMethods.PATCH, request, responses)
+
+    def post(
+        self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+    ) -> None:
         self._mock_request_method(SupportedHttpMethods.POST, request, responses)
 
+    def delete(
+        self, request: HttpRequest, responses: Union[HttpResponse, List[HttpResponse]]
+    ) -> None:
+        self._mock_request_method(SupportedHttpMethods.DELETE, request, responses)
+
     @staticmethod
-    def _matches_wrapper(matcher: HttpRequestMatcher) -> Callable[[requests_mock.request._RequestObjectProxy], bool]:
+    def _matches_wrapper(
+        matcher: HttpRequestMatcher,
+    ) -> Callable[[requests_mock.request._RequestObjectProxy], bool]:
         def matches(requests_mock_request: requests_mock.request._RequestObjectProxy) -> bool:
             # query_params are provided as part of `requests_mock_request.url`
             http_request = HttpRequest(
-                requests_mock_request.url, query_params={}, headers=requests_mock_request.headers, body=requests_mock_request.body
+                requests_mock_request.url,
+                query_params={},
+                headers=requests_mock_request.headers,
+                body=requests_mock_request.body,
             )
             return matcher.matches(http_request)
 
         return matches
 
     def assert_number_of_calls(self, request: HttpRequest, number_of_calls: int) -> None:
-        corresponding_matchers = list(filter(lambda matcher: matcher.request == request, self._matchers))
+        corresponding_matchers = list(
+            filter(lambda matcher: matcher.request == request, self._matchers)
+        )
         if len(corresponding_matchers) != 1:
-            raise ValueError(f"Was expecting only one matcher to match the request but got `{corresponding_matchers}`")
+            raise ValueError(
+                f"Was expecting only one matcher to match the request but got `{corresponding_matchers}`"
+            )
 
         assert corresponding_matchers[0].actual_number_of_matches == number_of_calls
 
@@ -100,7 +141,9 @@ class HttpMocker(contextlib.ContextDecorator):
                 try:
                     result = f(*args, **kwargs)
                 except requests_mock.NoMockAddress as no_mock_exception:
-                    matchers_as_string = "\n\t".join(map(lambda matcher: str(matcher.request), self._matchers))
+                    matchers_as_string = "\n\t".join(
+                        map(lambda matcher: str(matcher.request), self._matchers)
+                    )
                     raise ValueError(
                         f"No matcher matches {no_mock_exception.args[0]} with headers `{no_mock_exception.request.headers}` "
                         f"and body `{no_mock_exception.request.body}`. "
@@ -123,3 +166,7 @@ class HttpMocker(contextlib.ContextDecorator):
                 return result
 
         return wrapper
+
+    def clear_all_matchers(self) -> None:
+        """Clears all stored matchers by resetting the _matchers list to an empty state."""
+        self._matchers = []