airbyte-cdk 6.5.3rc2__py3-none-any.whl → 6.6.0__py3-none-any.whl

airbyte_cdk/test/catalog_builder.py

@@ -2,7 +2,12 @@
 
 from typing import Any, Dict, List, Union, overload
 
-from airbyte_cdk.models import ConfiguredAirbyteCatalog, ConfiguredAirbyteStream, ConfiguredAirbyteStreamSerializer, SyncMode
+from airbyte_cdk.models import (
+    ConfiguredAirbyteCatalog,
+    ConfiguredAirbyteStream,
+    ConfiguredAirbyteStreamSerializer,
+    SyncMode,
+)
 
 
 class ConfiguredAirbyteStreamBuilder:
@@ -45,14 +50,16 @@ class CatalogBuilder:
         self._streams: List[ConfiguredAirbyteStreamBuilder] = []
 
     @overload
-    def with_stream(self, name: ConfiguredAirbyteStreamBuilder) -> "CatalogBuilder":
-        ...
+    def with_stream(self, name: ConfiguredAirbyteStreamBuilder) -> "CatalogBuilder": ...
 
     @overload
-    def with_stream(self, name: str, sync_mode: SyncMode) -> "CatalogBuilder":
-        ...
+    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":
+    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)
 
@@ -61,10 +68,14 @@ class CatalogBuilder:
         builder = (
             name_or_builder
             if isinstance(name_or_builder, ConfiguredAirbyteStreamBuilder)
-            else ConfiguredAirbyteStreamBuilder().with_name(name_or_builder).with_sync_mode(sync_mode)
+            else ConfiguredAirbyteStreamBuilder()
+            .with_name(name_or_builder)
+            .with_sync_mode(sync_mode)
         )
         self._streams.append(builder)
         return self
 
     def build(self) -> ConfiguredAirbyteCatalog:
-        return ConfiguredAirbyteCatalog(streams=list(map(lambda builder: builder.build(), self._streams)))
+        return ConfiguredAirbyteCatalog(
+            streams=list(map(lambda builder: builder.build(), self._streams))
+        )

airbyte_cdk/test/entrypoint_wrapper.py

@@ -53,7 +53,11 @@ class EntrypointOutput:
             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:
@@ -61,7 +65,9 @@ class EntrypointOutput:
             return AirbyteMessageSerializer.load(orjson.loads(message))  # type: ignore[no-any-return] # Serializer.load() always returns AirbyteMessage
         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]:
@@ -119,18 +125,26 @@ 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]  # type: ignore[union-attr] # trace has `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, flags=re.IGNORECASE) for entry in self.logs)  # type: ignore[union-attr] # log has `message`
+        return any(
+            re.search(pattern, entry.log.message, flags=re.IGNORECASE) for entry in self.logs
+        )  # type: ignore[union-attr] # log has `message`
 
     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:
+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)
@@ -174,7 +188,9 @@ def discover(
         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)
+        return _run_command(
+            source, ["discover", "--config", config_file, "--debug"], expecting_exception
+        )
 
 
 def read(
@@ -194,7 +210,8 @@ def read(
         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()
+            tmp_directory_path / "catalog.json",
+            orjson.dumps(ConfiguredAirbyteCatalogSerializer.dump(catalog)).decode(),
         )
         args = [
             "read",
@@ -217,7 +234,9 @@ def read(
         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/mocker.py

@@ -42,7 +42,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:
@@ -51,7 +56,10 @@ 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]
@@ -65,37 +73,57 @@ class HttpMocker(contextlib.ContextDecorator):
             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 patch(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:
+    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:
+    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
 
@@ -110,7 +138,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}`. "

airbyte_cdk/test/mock_http/request.py

@@ -24,7 +24,9 @@ class HttpRequest:
         if not self._parsed_url.query and query_params:
             self._parsed_url = urlparse(f"{url}?{self._encode_qs(query_params)}")
         elif self._parsed_url.query and query_params:
-            raise ValueError("If query params are provided as part of the url, `query_params` should be empty")
+            raise ValueError(
+                "If query params are provided as part of the url, `query_params` should be empty"
+            )
 
         self._headers = headers or {}
         self._body = body
@@ -62,7 +64,9 @@ class HttpRequest:
         return False
 
     @staticmethod
-    def _to_mapping(body: Optional[Union[str, bytes, Mapping[str, Any]]]) -> Optional[Mapping[str, Any]]:
+    def _to_mapping(
+        body: Optional[Union[str, bytes, Mapping[str, Any]]],
+    ) -> Optional[Mapping[str, Any]]:
         if isinstance(body, Mapping):
             return body
         elif isinstance(body, bytes):
@@ -84,7 +88,9 @@ class HttpRequest:
         return f"{self._parsed_url} with headers {self._headers} and body {self._body!r})"
 
     def __repr__(self) -> str:
-        return f"HttpRequest(request={self._parsed_url}, headers={self._headers}, body={self._body!r})"
+        return (
+            f"HttpRequest(request={self._parsed_url}, headers={self._headers}, body={self._body!r})"
+        )
 
     def __eq__(self, other: Any) -> bool:
         if isinstance(other, HttpRequest):

airbyte_cdk/test/mock_http/response.py

@@ -5,7 +5,9 @@ from typing import Mapping
 
 
 class HttpResponse:
-    def __init__(self, body: str, status_code: int = 200, headers: Mapping[str, str] = MappingProxyType({})):
+    def __init__(
+        self, body: str, status_code: int = 200, headers: Mapping[str, str] = MappingProxyType({})
+    ):
         self._body = body
         self._status_code = status_code
         self._headers = headers

airbyte_cdk/test/mock_http/response_builder.py

@@ -91,7 +91,12 @@ class FieldUpdatePaginationStrategy(PaginationStrategy):
 
 
 class RecordBuilder:
-    def __init__(self, template: Dict[str, Any], id_path: Optional[Path], cursor_path: Optional[Union[FieldPath, NestedPath]]):
+    def __init__(
+        self,
+        template: Dict[str, Any],
+        id_path: Optional[Path],
+        cursor_path: Optional[Union[FieldPath, NestedPath]],
+    ):
         self._record = template
         self._id_path = id_path
         self._cursor_path = cursor_path
@@ -109,9 +114,13 @@ class RecordBuilder:
     def _validate_field(self, field_name: str, path: Optional[Path]) -> None:
         try:
             if path and not path.extract(self._record):
-                raise ValueError(f"{field_name} `{path}` was provided but it is not part of the template `{self._record}`")
+                raise ValueError(
+                    f"{field_name} `{path}` was provided but it is not part of the template `{self._record}`"
+                )
         except (IndexError, KeyError) as exception:
-            raise ValueError(f"{field_name} `{path}` was provided but it is not part of the template `{self._record}`") from exception
+            raise ValueError(
+                f"{field_name} `{path}` was provided but it is not part of the template `{self._record}`"
+            ) from exception
 
     def with_id(self, identifier: Any) -> "RecordBuilder":
         self._set_field("id", self._id_path, identifier)
@@ -139,7 +148,10 @@ class RecordBuilder:
 
 class HttpResponseBuilder:
     def __init__(
-        self, template: Dict[str, Any], records_path: Union[FieldPath, NestedPath], pagination_strategy: Optional[PaginationStrategy]
+        self,
+        template: Dict[str, Any],
+        records_path: Union[FieldPath, NestedPath],
+        pagination_strategy: Optional[PaginationStrategy],
     ):
         self._response = template
         self._records: List[RecordBuilder] = []
@@ -175,7 +187,13 @@ def _get_unit_test_folder(execution_folder: str) -> FilePath:
 
 
 def find_template(resource: str, execution_folder: str) -> Dict[str, Any]:
-    response_template_filepath = str(get_unit_test_folder(execution_folder) / "resource" / "http" / "response" / f"{resource}.json")
+    response_template_filepath = str(
+        get_unit_test_folder(execution_folder)
+        / "resource"
+        / "http"
+        / "response"
+        / f"{resource}.json"
+    )
     with open(response_template_filepath, "r") as template_file:
         return json.load(template_file)  # type: ignore  # we assume the dev correctly set up the resource file
 
@@ -198,10 +216,14 @@ def create_record_builder(
             )
         return RecordBuilder(record_template, record_id_path, record_cursor_path)
     except (IndexError, KeyError):
-        raise ValueError(f"Error while extracting records at path `{records_path}` from response template `{response_template}`")
+        raise ValueError(
+            f"Error while extracting records at path `{records_path}` from response template `{response_template}`"
+        )
 
 
 def create_response_builder(
-    response_template: Dict[str, Any], records_path: Union[FieldPath, NestedPath], pagination_strategy: Optional[PaginationStrategy] = None
+    response_template: Dict[str, Any],
+    records_path: Union[FieldPath, NestedPath],
+    pagination_strategy: Optional[PaginationStrategy] = None,
 ) -> HttpResponseBuilder:
     return HttpResponseBuilder(response_template, records_path, pagination_strategy)

airbyte_cdk/test/state_builder.py

@@ -2,7 +2,13 @@
 
 from typing import Any, List
 
-from airbyte_cdk.models import AirbyteStateBlob, AirbyteStateMessage, AirbyteStateType, AirbyteStreamState, StreamDescriptor
+from airbyte_cdk.models import (
+    AirbyteStateBlob,
+    AirbyteStateMessage,
+    AirbyteStateType,
+    AirbyteStreamState,
+    StreamDescriptor,
+)
 
 
 class StateBuilder:
@@ -14,7 +20,9 @@ class StateBuilder:
             AirbyteStateMessage(
                 type=AirbyteStateType.STREAM,
                 stream=AirbyteStreamState(
-                    stream_state=state if isinstance(state, AirbyteStateBlob) else AirbyteStateBlob(state),
+                    stream_state=state
+                    if isinstance(state, AirbyteStateBlob)
+                    else AirbyteStateBlob(state),
                     stream_descriptor=StreamDescriptor(**{"name": stream_name}),
                 ),
             )

airbyte_cdk/test/utils/data.py

@@ -7,14 +7,18 @@ def get_unit_test_folder(execution_folder: str) -> FilePath:
     path = FilePath(execution_folder)
     while path.name != "unit_tests":
         if path.name == path.root or path.name == path.drive:
-            raise ValueError(f"Could not find `unit_tests` folder as a parent of {execution_folder}")
+            raise ValueError(
+                f"Could not find `unit_tests` folder as a parent of {execution_folder}"
+            )
         path = path.parent
     return path
 
 
 def read_resource_file_contents(resource: str, test_location: str) -> str:
     """Read the contents of a test data file from the test resource folder."""
-    file_path = str(get_unit_test_folder(test_location) / "resource" / "http" / "response" / f"{resource}")
+    file_path = str(
+        get_unit_test_folder(test_location) / "resource" / "http" / "response" / f"{resource}"
+    )
     with open(file_path) as f:
         response = f.read()
     return response

airbyte_cdk/test/utils/http_mocking.py

@@ -6,7 +6,9 @@ from typing import Any, Mapping
 from requests_mock import Mocker
 
 
-def register_mock_responses(mocker: Mocker, http_calls: list[Mapping[str, Mapping[str, Any]]]) -> None:
+def register_mock_responses(
+    mocker: Mocker, http_calls: list[Mapping[str, Mapping[str, Any]]]
+) -> None:
     """Register a list of HTTP request-response pairs."""
     for call in http_calls:
         request, response = call["request"], call["response"]

airbyte_cdk/utils/airbyte_secrets_utils.py

@@ -36,7 +36,9 @@ def get_secret_paths(spec: Mapping[str, Any]) -> List[List[str]]:
     return paths
 
 
-def get_secrets(connection_specification: Mapping[str, Any], config: Mapping[str, Any]) -> List[Any]:
+def get_secrets(
+    connection_specification: Mapping[str, Any], config: Mapping[str, Any]
+) -> List[Any]:
     """
     Get a list of secret values from the source config based on the source specification
     :type connection_specification: the connection_specification field of an AirbyteSpecification i.e the JSONSchema definition

airbyte_cdk/utils/analytics_message.py

@@ -3,7 +3,13 @@
 import time
 from typing import Any, Optional
 
-from airbyte_cdk.models import AirbyteAnalyticsTraceMessage, AirbyteMessage, AirbyteTraceMessage, TraceType, Type
+from airbyte_cdk.models import (
+    AirbyteAnalyticsTraceMessage,
+    AirbyteMessage,
+    AirbyteTraceMessage,
+    TraceType,
+    Type,
+)
 
 
 def create_analytics_message(type: str, value: Optional[Any]) -> AirbyteMessage:
@@ -12,6 +18,8 @@ def create_analytics_message(type: str, value: Optional[Any]) -> AirbyteMessage:
         trace=AirbyteTraceMessage(
             type=TraceType.ANALYTICS,
             emitted_at=time.time() * 1000,
-            analytics=AirbyteAnalyticsTraceMessage(type=type, value=str(value) if value is not None else None),
+            analytics=AirbyteAnalyticsTraceMessage(
+                type=type, value=str(value) if value is not None else None
+            ),
         ),
     )

airbyte_cdk/utils/datetime_format_inferrer.py

@@ -29,7 +29,10 @@ class DatetimeFormatInferrer:
             "%Y-%m",
             "%d-%m-%Y",
         ]
-        self._timestamp_heuristic_ranges = [range(1_000_000_000, 2_000_000_000), range(1_000_000_000_000, 2_000_000_000_000)]
+        self._timestamp_heuristic_ranges = [
+            range(1_000_000_000, 2_000_000_000),
+            range(1_000_000_000_000, 2_000_000_000_000),
+        ]
 
     def _can_be_datetime(self, value: Any) -> bool:
         """Checks if the value can be a datetime.

airbyte_cdk/utils/mapping_helpers.py

@@ -6,7 +6,9 @@
 from typing import Any, List, Mapping, Optional, Set, Union
 
 
-def combine_mappings(mappings: List[Optional[Union[Mapping[str, Any], str]]]) -> Union[Mapping[str, Any], str]:
+def combine_mappings(
+    mappings: List[Optional[Union[Mapping[str, Any], str]]],
+) -> Union[Mapping[str, Any], str]:
     """
     Combine multiple mappings into a single mapping. If any of the mappings are a string, return
     that string. Raise errors in the following cases:

airbyte_cdk/utils/message_utils.py

@@ -7,12 +7,19 @@ from airbyte_cdk.sources.connector_state_manager import HashableStreamDescriptor
 def get_stream_descriptor(message: AirbyteMessage) -> HashableStreamDescriptor:
     match message.type:
         case Type.RECORD:
-            return HashableStreamDescriptor(name=message.record.stream, namespace=message.record.namespace)  # type: ignore[union-attr] # record has `stream` and `namespace`
+            return HashableStreamDescriptor(
+                name=message.record.stream, namespace=message.record.namespace
+            )  # type: ignore[union-attr] # record has `stream` and `namespace`
         case Type.STATE:
             if not message.state.stream or not message.state.stream.stream_descriptor:  # type: ignore[union-attr] # state has `stream`
-                raise ValueError("State message was not in per-stream state format, which is required for record counts.")
+                raise ValueError(
+                    "State message was not in per-stream state format, which is required for record counts."
+                )
             return HashableStreamDescriptor(
-                name=message.state.stream.stream_descriptor.name, namespace=message.state.stream.stream_descriptor.namespace  # type: ignore[union-attr] # state has `stream`
+                name=message.state.stream.stream_descriptor.name,
+                namespace=message.state.stream.stream_descriptor.namespace,  # type: ignore[union-attr] # state has `stream`
             )
         case _:
-            raise NotImplementedError(f"get_stream_descriptor is not implemented for message type '{message.type}'.")
+            raise NotImplementedError(
+                f"get_stream_descriptor is not implemented for message type '{message.type}'."
+            )

airbyte_cdk/utils/print_buffer.py

@@ -65,6 +65,11 @@ class PrintBuffer:
             sys.stderr = self
         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.flush()
         sys.stdout, sys.stderr = self.old_stdout, self.old_stderr

airbyte_cdk/utils/schema_inferrer.py

@@ -55,9 +55,14 @@ InferredSchema = Dict[str, Any]
 
 class SchemaValidationException(Exception):
     @classmethod
-    def merge_exceptions(cls, exceptions: List["SchemaValidationException"]) -> "SchemaValidationException":
+    def merge_exceptions(
+        cls, exceptions: List["SchemaValidationException"]
+    ) -> "SchemaValidationException":
         # We assume the schema is the same for all SchemaValidationException
-        return SchemaValidationException(exceptions[0].schema, [x for exception in exceptions for x in exception._validation_errors])
+        return SchemaValidationException(
+            exceptions[0].schema,
+            [x for exception in exceptions for x in exception._validation_errors],
+        )
 
     def __init__(self, schema: InferredSchema, validation_errors: List[Exception]):
         self._schema = schema
@@ -84,7 +89,9 @@ class SchemaInferrer:
 
     stream_to_builder: Dict[str, SchemaBuilder]
 
-    def __init__(self, pk: Optional[List[List[str]]] = None, cursor_field: Optional[List[List[str]]] = None) -> None:
+    def __init__(
+        self, pk: Optional[List[List[str]]] = None, cursor_field: Optional[List[List[str]]] = None
+    ) -> None:
         self.stream_to_builder = defaultdict(NoRequiredSchemaBuilder)
         self._pk = [] if pk is None else pk
         self._cursor_field = [] if cursor_field is None else cursor_field
@@ -105,7 +112,9 @@ class SchemaInferrer:
 
     def _clean_any_of(self, node: InferredSchema) -> None:
         if len(node[_ANY_OF]) == 2 and self._null_type_in_any_of(node):
-            real_type = node[_ANY_OF][1] if node[_ANY_OF][0][_TYPE] == _NULL_TYPE else node[_ANY_OF][0]
+            real_type = (
+                node[_ANY_OF][1] if node[_ANY_OF][0][_TYPE] == _NULL_TYPE else node[_ANY_OF][0]
+            )
             node.update(real_type)
             node[_TYPE] = [node[_TYPE], _NULL_TYPE]
             node.pop(_ANY_OF)
@@ -189,7 +198,9 @@ class SchemaInferrer:
         if errors:
             raise SchemaValidationException(node, errors)
 
-    def _add_field_as_required(self, node: InferredSchema, path: List[str], traveled_path: Optional[List[str]] = None) -> None:
+    def _add_field_as_required(
+        self, node: InferredSchema, path: List[str], traveled_path: Optional[List[str]] = None
+    ) -> None:
         """
         Take a nested key and travel the schema to mark every node as required.
         """
@@ -208,7 +219,9 @@ class SchemaInferrer:
 
         next_node = path[0]
         if next_node not in node[_PROPERTIES]:
-            raise ValueError(f"Path {traveled_path} does not have field `{next_node}` in the schema and hence can't be marked as required.")
+            raise ValueError(
+                f"Path {traveled_path} does not have field `{next_node}` in the schema and hence can't be marked as required."
+            )
 
         if _TYPE not in node:
             # We do not expect this case to happen but we added a specific error message just in case
@@ -216,8 +229,14 @@ class SchemaInferrer:
                 f"Unknown schema error: {traveled_path} is expected to have a type but did not. Schema inferrence is probably broken"
             )
 
-        if node[_TYPE] not in [_OBJECT_TYPE, [_NULL_TYPE, _OBJECT_TYPE], [_OBJECT_TYPE, _NULL_TYPE]]:
-            raise ValueError(f"Path {traveled_path} is expected to be an object but was of type `{node['properties'][next_node]['type']}`")
+        if node[_TYPE] not in [
+            _OBJECT_TYPE,
+            [_NULL_TYPE, _OBJECT_TYPE],
+            [_OBJECT_TYPE, _NULL_TYPE],
+        ]:
+            raise ValueError(
+                f"Path {traveled_path} is expected to be an object but was of type `{node['properties'][next_node]['type']}`"
+            )
 
         if _REQUIRED not in node or not node[_REQUIRED]:
             node[_REQUIRED] = [next_node]
@@ -242,7 +261,9 @@ class SchemaInferrer:
         Returns the inferred JSON schema for the specified stream. Might be `None` if there were no records for the given stream name.
         """
         return (
-            self._add_required_properties(self._clean(self.stream_to_builder[stream_name].to_schema()))
+            self._add_required_properties(
+                self._clean(self.stream_to_builder[stream_name].to_schema())
+            )
             if stream_name in self.stream_to_builder
             else None
         )

airbyte_cdk/utils/spec_schema_transformations.py

@@ -17,7 +17,9 @@ def resolve_refs(schema: dict) -> dict:
     str_schema = json.dumps(schema)
     for ref_block in re.findall(r'{"\$ref": "#\/definitions\/.+?(?="})"}', str_schema):
         ref = json.loads(ref_block)["$ref"]
-        str_schema = str_schema.replace(ref_block, json.dumps(json_schema_ref_resolver.resolve(ref)[1]))
+        str_schema = str_schema.replace(
+            ref_block, json.dumps(json_schema_ref_resolver.resolve(ref)[1])
+        )
     pyschema: dict = json.loads(str_schema)
     del pyschema["definitions"]
     return pyschema