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

airbyte_cdk/__init__.py

@@ -46,7 +46,7 @@ API Reference
 # Imports should also be placed in `if TYPE_CHECKING` blocks if they are only used as type
 # hints - again, to avoid circular dependencies.
 # Once those issues are resolved, the below can be sorted with isort.
-from importlib import metadata
+import dunamai as _dunamai
 
 from .destinations import Destination
 from .models import AirbyteConnectionStatus, AirbyteMessage, ConfiguredAirbyteCatalog, Status, Type, FailureType, AirbyteStream, AdvancedAuth, DestinationSyncMode, ConnectorSpecification, OAuthConfigSpecification, OrchestratorType, ConfiguredAirbyteStream, SyncMode, AirbyteLogMessage, Level, AirbyteRecordMessage
@@ -281,4 +281,19 @@ __all__ = [
     "Source",
     "StreamSlice",
 ]
-__version__ = metadata.version("airbyte_cdk")
+
+__version__: str
+"""Version generated by poetry dynamic versioning during publish.
+
+When running in development, dunamai will calculate a new prerelease version
+from existing git release tag info.
+"""
+
+try:
+    __version__ = _dunamai.get_version(
+        "airbyte-cdk",
+        third_choice=_dunamai.Version.from_any_vcs,
+        fallback=_dunamai.Version("0.0.0+dev"),
+    ).serialize()
+except:
+    __version__ = "0.0.0+dev"

airbyte_cdk/config_observation.py

@@ -23,7 +23,10 @@ from orjson import orjson
 
 class ObservedDict(dict):  # type: ignore # disallow_any_generics is set to True, and dict is equivalent to dict[Any]
     def __init__(
-        self, non_observed_mapping: MutableMapping[Any, Any], observer: ConfigObserver, update_on_unchanged_value: bool = True
+        self,
+        non_observed_mapping: MutableMapping[Any, Any],
+        observer: ConfigObserver,
+        update_on_unchanged_value: bool = True,
     ) -> None:
         non_observed_mapping = copy(non_observed_mapping)
         self.observer = observer
@@ -69,11 +72,15 @@ class ConfigObserver:
         emit_configuration_as_airbyte_control_message(self.config)
 
 
-def observe_connector_config(non_observed_connector_config: MutableMapping[str, Any]) -> ObservedDict:
+def observe_connector_config(
+    non_observed_connector_config: MutableMapping[str, Any],
+) -> ObservedDict:
     if isinstance(non_observed_connector_config, ObservedDict):
         raise ValueError("This connector configuration is already observed")
     connector_config_observer = ConfigObserver()
-    observed_connector_config = ObservedDict(non_observed_connector_config, connector_config_observer)
+    observed_connector_config = ObservedDict(
+        non_observed_connector_config, connector_config_observer
+    )
     connector_config_observer.set_config(observed_connector_config)
     return observed_connector_config
 

airbyte_cdk/connector.py

@@ -11,7 +11,11 @@ from abc import ABC, abstractmethod
 from typing import Any, Generic, Mapping, Optional, Protocol, TypeVar
 
 import yaml
-from airbyte_cdk.models import AirbyteConnectionStatus, ConnectorSpecification, ConnectorSpecificationSerializer
+from airbyte_cdk.models import (
+    AirbyteConnectionStatus,
+    ConnectorSpecification,
+    ConnectorSpecificationSerializer,
+)
 
 
 def load_optional_package_file(package: str, filename: str) -> Optional[bytes]:
@@ -53,7 +57,9 @@ class BaseConnector(ABC, Generic[TConfig]):
         try:
             return json.loads(contents)
         except json.JSONDecodeError as error:
-            raise ValueError(f"Could not read json file {file_path}: {error}. Please ensure that it is a valid JSON.")
+            raise ValueError(
+                f"Could not read json file {file_path}: {error}. Please ensure that it is a valid JSON."
+            )
 
     @staticmethod
     def write_config(config: TConfig, config_path: str) -> None:
@@ -72,7 +78,9 @@ class BaseConnector(ABC, Generic[TConfig]):
         json_spec = load_optional_package_file(package, "spec.json")
 
         if yaml_spec and json_spec:
-            raise RuntimeError("Found multiple spec files in the package. Only one of spec.yaml or spec.json should be provided.")
+            raise RuntimeError(
+                "Found multiple spec files in the package. Only one of spec.yaml or spec.json should be provided."
+            )
 
         if yaml_spec:
             spec_obj = yaml.load(yaml_spec, Loader=yaml.SafeLoader)
@@ -80,7 +88,9 @@ class BaseConnector(ABC, Generic[TConfig]):
             try:
                 spec_obj = json.loads(json_spec)
             except json.JSONDecodeError as error:
-                raise ValueError(f"Could not read json spec file: {error}. Please ensure that it is a valid JSON.")
+                raise ValueError(
+                    f"Could not read json spec file: {error}. Please ensure that it is a valid JSON."
+                )
         else:
             raise FileNotFoundError("Unable to find spec.yaml or spec.json in the package.")
 
@@ -96,17 +106,17 @@ class BaseConnector(ABC, Generic[TConfig]):
 
 class _WriteConfigProtocol(Protocol):
     @staticmethod
-    def write_config(config: Mapping[str, Any], config_path: str) -> None:
-        ...
+    def write_config(config: Mapping[str, Any], config_path: str) -> None: ...
 
 
 class DefaultConnectorMixin:
     # can be overridden to change an input config
-    def configure(self: _WriteConfigProtocol, config: Mapping[str, Any], temp_dir: str) -> Mapping[str, Any]:
+    def configure(
+        self: _WriteConfigProtocol, config: Mapping[str, Any], temp_dir: str
+    ) -> Mapping[str, Any]:
         config_path = os.path.join(temp_dir, "config.json")
         self.write_config(config, config_path)
         return config
 
 
-class Connector(DefaultConnectorMixin, BaseConnector[Mapping[str, Any]], ABC):
-    ...
+class Connector(DefaultConnectorMixin, BaseConnector[Mapping[str, Any]], ABC): ...

airbyte_cdk/connector_builder/connector_builder_handler.py

@@ -7,12 +7,19 @@ from datetime import datetime
 from typing import Any, List, Mapping
 
 from airbyte_cdk.connector_builder.message_grouper import MessageGrouper
-from airbyte_cdk.models import AirbyteMessage, AirbyteRecordMessage, AirbyteStateMessage, ConfiguredAirbyteCatalog
+from airbyte_cdk.models import (
+    AirbyteMessage,
+    AirbyteRecordMessage,
+    AirbyteStateMessage,
+    ConfiguredAirbyteCatalog,
+)
 from airbyte_cdk.models import Type
 from airbyte_cdk.models import Type as MessageType
 from airbyte_cdk.sources.declarative.declarative_source import DeclarativeSource
 from airbyte_cdk.sources.declarative.manifest_declarative_source import ManifestDeclarativeSource
-from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import ModelToComponentFactory
+from airbyte_cdk.sources.declarative.parsers.model_to_component_factory import (
+    ModelToComponentFactory,
+)
 from airbyte_cdk.utils.airbyte_secrets_utils import filter_secrets
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 
@@ -34,7 +41,9 @@ class TestReadLimits:
 
 def get_limits(config: Mapping[str, Any]) -> TestReadLimits:
     command_config = config.get("__test_read_config", {})
-    max_pages_per_slice = command_config.get(MAX_PAGES_PER_SLICE_KEY) or DEFAULT_MAXIMUM_NUMBER_OF_PAGES_PER_SLICE
+    max_pages_per_slice = (
+        command_config.get(MAX_PAGES_PER_SLICE_KEY) or DEFAULT_MAXIMUM_NUMBER_OF_PAGES_PER_SLICE
+    )
     max_slices = command_config.get(MAX_SLICES_KEY) or DEFAULT_MAXIMUM_NUMBER_OF_SLICES
     max_records = command_config.get(MAX_RECORDS_KEY) or DEFAULT_MAXIMUM_RECORDS
     return TestReadLimits(max_records, max_pages_per_slice, max_slices)
@@ -64,15 +73,24 @@ def read_stream(
 ) -> AirbyteMessage:
     try:
         handler = MessageGrouper(limits.max_pages_per_slice, limits.max_slices, limits.max_records)
-        stream_name = configured_catalog.streams[0].stream.name  # The connector builder only supports a single stream
-        stream_read = handler.get_message_groups(source, config, configured_catalog, state, limits.max_records)
+        stream_name = configured_catalog.streams[
+            0
+        ].stream.name  # The connector builder only supports a single stream
+        stream_read = handler.get_message_groups(
+            source, config, configured_catalog, state, limits.max_records
+        )
         return AirbyteMessage(
             type=MessageType.RECORD,
-            record=AirbyteRecordMessage(data=dataclasses.asdict(stream_read), stream=stream_name, emitted_at=_emitted_at()),
+            record=AirbyteRecordMessage(
+                data=dataclasses.asdict(stream_read), stream=stream_name, emitted_at=_emitted_at()
+            ),
         )
     except Exception as exc:
         error = AirbyteTracedException.from_exception(
-            exc, message=filter_secrets(f"Error reading stream with config={config} and catalog={configured_catalog}: {str(exc)}")
+            exc,
+            message=filter_secrets(
+                f"Error reading stream with config={config} and catalog={configured_catalog}: {str(exc)}"
+            ),
         )
         return error.as_airbyte_message()
 
@@ -88,7 +106,9 @@ def resolve_manifest(source: ManifestDeclarativeSource) -> AirbyteMessage:
             ),
         )
     except Exception as exc:
-        error = AirbyteTracedException.from_exception(exc, message=f"Error resolving manifest: {str(exc)}")
+        error = AirbyteTracedException.from_exception(
+            exc, message=f"Error resolving manifest: {str(exc)}"
+        )
         return error.as_airbyte_message()
 
 

airbyte_cdk/connector_builder/main.py

@@ -7,7 +7,13 @@ import sys
 from typing import Any, List, Mapping, Optional, Tuple
 
 from airbyte_cdk.connector import BaseConnector
-from airbyte_cdk.connector_builder.connector_builder_handler import TestReadLimits, create_source, get_limits, read_stream, resolve_manifest
+from airbyte_cdk.connector_builder.connector_builder_handler import (
+    TestReadLimits,
+    create_source,
+    get_limits,
+    read_stream,
+    resolve_manifest,
+)
 from airbyte_cdk.entrypoint import AirbyteEntrypoint
 from airbyte_cdk.models import (
     AirbyteMessage,
@@ -22,11 +28,17 @@ from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 from orjson import orjson
 
 
-def get_config_and_catalog_from_args(args: List[str]) -> Tuple[str, Mapping[str, Any], Optional[ConfiguredAirbyteCatalog], Any]:
+def get_config_and_catalog_from_args(
+    args: List[str],
+) -> Tuple[str, Mapping[str, Any], Optional[ConfiguredAirbyteCatalog], Any]:
     # TODO: Add functionality for the `debug` logger.
     #  Currently, no one `debug` level log will be displayed during `read` a stream for a connector created through `connector-builder`.
     parsed_args = AirbyteEntrypoint.parse_args(args)
-    config_path, catalog_path, state_path = parsed_args.config, parsed_args.catalog, parsed_args.state
+    config_path, catalog_path, state_path = (
+        parsed_args.config,
+        parsed_args.catalog,
+        parsed_args.state,
+    )
     if parsed_args.command != "read":
         raise ValueError("Only read commands are allowed for Connector Builder requests.")
 
@@ -64,7 +76,9 @@ def handle_connector_builder_request(
     if command == "resolve_manifest":
         return resolve_manifest(source)
     elif command == "test_read":
-        assert catalog is not None, "`test_read` requires a valid `ConfiguredAirbyteCatalog`, got None."
+        assert (
+            catalog is not None
+        ), "`test_read` requires a valid `ConfiguredAirbyteCatalog`, got None."
         return read_stream(source, config, catalog, state, limits)
     else:
         raise ValueError(f"Unrecognized command {command}.")
@@ -74,13 +88,19 @@ def handle_request(args: List[str]) -> str:
     command, config, catalog, state = get_config_and_catalog_from_args(args)
     limits = get_limits(config)
     source = create_source(config, limits)
-    return orjson.dumps(AirbyteMessageSerializer.dump(handle_connector_builder_request(source, command, config, catalog, state, limits))).decode()  # type: ignore[no-any-return] # Serializer.dump() always returns AirbyteMessage
+    return orjson.dumps(
+        AirbyteMessageSerializer.dump(
+            handle_connector_builder_request(source, command, config, catalog, state, limits)
+        )
+    ).decode()  # type: ignore[no-any-return] # Serializer.dump() always returns AirbyteMessage
 
 
 if __name__ == "__main__":
     try:
         print(handle_request(sys.argv[1:]))
     except Exception as exc:
-        error = AirbyteTracedException.from_exception(exc, message=f"Error handling request: {str(exc)}")
+        error = AirbyteTracedException.from_exception(
+            exc, message=f"Error handling request: {str(exc)}"
+        )
         m = error.as_airbyte_message()
         print(orjson.dumps(AirbyteMessageSerializer.dump(m)).decode())

airbyte_cdk/connector_builder/message_grouper.py

@@ -45,7 +45,9 @@ class MessageGrouper:
         self._max_slices = max_slices
         self._max_record_limit = max_record_limit
 
-    def _pk_to_nested_and_composite_field(self, field: Optional[Union[str, List[str], List[List[str]]]]) -> List[List[str]]:
+    def _pk_to_nested_and_composite_field(
+        self, field: Optional[Union[str, List[str], List[List[str]]]]
+    ) -> List[List[str]]:
         if not field:
             return [[]]
 
@@ -58,7 +60,9 @@ class MessageGrouper:
 
         return field  # type: ignore  # the type of field is expected to be List[List[str]] here
 
-    def _cursor_field_to_nested_and_composite_field(self, field: Union[str, List[str]]) -> List[List[str]]:
+    def _cursor_field_to_nested_and_composite_field(
+        self, field: Union[str, List[str]]
+    ) -> List[List[str]]:
         if not field:
             return [[]]
 
@@ -80,8 +84,12 @@ class MessageGrouper:
         record_limit: Optional[int] = None,
     ) -> StreamRead:
         if record_limit is not None and not (1 <= record_limit <= self._max_record_limit):
-            raise ValueError(f"Record limit must be between 1 and {self._max_record_limit}. Got {record_limit}")
-        stream = source.streams(config)[0]  # The connector builder currently only supports reading from a single stream at a time
+            raise ValueError(
+                f"Record limit must be between 1 and {self._max_record_limit}. Got {record_limit}"
+            )
+        stream = source.streams(config)[
+            0
+        ]  # The connector builder currently only supports reading from a single stream at a time
         schema_inferrer = SchemaInferrer(
             self._pk_to_nested_and_composite_field(stream.primary_key),
             self._cursor_field_to_nested_and_composite_field(stream.cursor_field),
@@ -104,7 +112,11 @@ class MessageGrouper:
             record_limit,
         ):
             if isinstance(message_group, AirbyteLogMessage):
-                log_messages.append(LogMessage(**{"message": message_group.message, "level": message_group.level.value}))
+                log_messages.append(
+                    LogMessage(
+                        **{"message": message_group.message, "level": message_group.level.value}
+                    )
+                )
             elif isinstance(message_group, AirbyteTraceMessage):
                 if message_group.type == TraceType.ERROR:
                     log_messages.append(
@@ -118,7 +130,10 @@ class MessageGrouper:
                         )
                     )
             elif isinstance(message_group, AirbyteControlMessage):
-                if not latest_config_update or latest_config_update.emitted_at <= message_group.emitted_at:
+                if (
+                    not latest_config_update
+                    or latest_config_update.emitted_at <= message_group.emitted_at
+                ):
                     latest_config_update = message_group
             elif isinstance(message_group, AuxiliaryRequest):
                 auxiliary_requests.append(message_group)
@@ -142,7 +157,9 @@ class MessageGrouper:
             test_read_limit_reached=self._has_reached_limit(slices),
             auxiliary_requests=auxiliary_requests,
             inferred_schema=schema,
-            latest_config_update=self._clean_config(latest_config_update.connectorConfig.config) if latest_config_update else None,
+            latest_config_update=self._clean_config(latest_config_update.connectorConfig.config)
+            if latest_config_update
+            else None,
             inferred_datetime_formats=datetime_format_inferrer.get_inferred_datetime_formats(),
         )
 
@@ -152,7 +169,15 @@ class MessageGrouper:
         schema_inferrer: SchemaInferrer,
         datetime_format_inferrer: DatetimeFormatInferrer,
         limit: int,
-    ) -> Iterable[Union[StreamReadPages, AirbyteControlMessage, AirbyteLogMessage, AirbyteTraceMessage, AuxiliaryRequest]]:
+    ) -> Iterable[
+        Union[
+            StreamReadPages,
+            AirbyteControlMessage,
+            AirbyteLogMessage,
+            AirbyteTraceMessage,
+            AuxiliaryRequest,
+        ]
+    ]:
         """
         Message groups are partitioned according to when request log messages are received. Subsequent response log messages
         and record messages belong to the prior request log message and when we encounter another request, append the latest
@@ -180,10 +205,17 @@ class MessageGrouper:
         while records_count < limit and (message := next(messages, None)):
             json_object = self._parse_json(message.log) if message.type == MessageType.LOG else None
             if json_object is not None and not isinstance(json_object, dict):
-                raise ValueError(f"Expected log message to be a dict, got {json_object} of type {type(json_object)}")
+                raise ValueError(
+                    f"Expected log message to be a dict, got {json_object} of type {type(json_object)}"
+                )
             json_message: Optional[Dict[str, JsonType]] = json_object
             if self._need_to_close_page(at_least_one_page_in_group, message, json_message):
-                self._close_page(current_page_request, current_page_response, current_slice_pages, current_page_records)
+                self._close_page(
+                    current_page_request,
+                    current_page_response,
+                    current_slice_pages,
+                    current_page_records,
+                )
                 current_page_request = None
                 current_page_response = None
 
@@ -200,7 +232,9 @@ class MessageGrouper:
                 current_slice_descriptor = self._parse_slice_description(message.log.message)  # type: ignore[union-attr] # AirbyteMessage with MessageType.LOG has log.message
                 current_slice_pages = []
                 at_least_one_page_in_group = False
-            elif message.type == MessageType.LOG and message.log.message.startswith(SliceLogger.SLICE_LOG_PREFIX):  # type: ignore[union-attr] # AirbyteMessage with MessageType.LOG has log.message
+            elif message.type == MessageType.LOG and message.log.message.startswith(
+                SliceLogger.SLICE_LOG_PREFIX
+            ):  # type: ignore[union-attr] # AirbyteMessage with MessageType.LOG has log.message
                 # parsing the first slice
                 current_slice_descriptor = self._parse_slice_description(message.log.message)  # type: ignore[union-attr] # AirbyteMessage with MessageType.LOG has log.message
             elif message.type == MessageType.LOG:
@@ -208,14 +242,22 @@ class MessageGrouper:
                     if self._is_auxiliary_http_request(json_message):
                         airbyte_cdk = json_message.get("airbyte_cdk", {})
                         if not isinstance(airbyte_cdk, dict):
-                            raise ValueError(f"Expected airbyte_cdk to be a dict, got {airbyte_cdk} of type {type(airbyte_cdk)}")
+                            raise ValueError(
+                                f"Expected airbyte_cdk to be a dict, got {airbyte_cdk} of type {type(airbyte_cdk)}"
+                            )
                         stream = airbyte_cdk.get("stream", {})
                         if not isinstance(stream, dict):
-                            raise ValueError(f"Expected stream to be a dict, got {stream} of type {type(stream)}")
-                        title_prefix = "Parent stream: " if stream.get("is_substream", False) else ""
+                            raise ValueError(
+                                f"Expected stream to be a dict, got {stream} of type {type(stream)}"
+                            )
+                        title_prefix = (
+                            "Parent stream: " if stream.get("is_substream", False) else ""
+                        )
                         http = json_message.get("http", {})
                         if not isinstance(http, dict):
-                            raise ValueError(f"Expected http to be a dict, got {http} of type {type(http)}")
+                            raise ValueError(
+                                f"Expected http to be a dict, got {http} of type {type(http)}"
+                            )
                         yield AuxiliaryRequest(
                             title=title_prefix + str(http.get("title", None)),
                             description=str(http.get("description", None)),
@@ -236,13 +278,21 @@ class MessageGrouper:
                 records_count += 1
                 schema_inferrer.accumulate(message.record)
                 datetime_format_inferrer.accumulate(message.record)
-            elif message.type == MessageType.CONTROL and message.control.type == OrchestratorType.CONNECTOR_CONFIG:  # type: ignore[union-attr] # AirbyteMessage with MessageType.CONTROL has control.type
+            elif (
+                message.type == MessageType.CONTROL
+                and message.control.type == OrchestratorType.CONNECTOR_CONFIG
+            ):  # type: ignore[union-attr] # AirbyteMessage with MessageType.CONTROL has control.type
                 yield message.control
             elif message.type == MessageType.STATE:
                 latest_state_message = message.state  # type: ignore[assignment]
         else:
             if current_page_request or current_page_response or current_page_records:
-                self._close_page(current_page_request, current_page_response, current_slice_pages, current_page_records)
+                self._close_page(
+                    current_page_request,
+                    current_page_response,
+                    current_slice_pages,
+                    current_page_records,
+                )
                 yield StreamReadSlices(
                     pages=current_slice_pages,
                     slice_descriptor=current_slice_descriptor,
@@ -250,11 +300,18 @@ class MessageGrouper:
                 )
 
     @staticmethod
-    def _need_to_close_page(at_least_one_page_in_group: bool, message: AirbyteMessage, json_message: Optional[Dict[str, Any]]) -> bool:
+    def _need_to_close_page(
+        at_least_one_page_in_group: bool,
+        message: AirbyteMessage,
+        json_message: Optional[Dict[str, Any]],
+    ) -> bool:
         return (
             at_least_one_page_in_group
             and message.type == MessageType.LOG
-            and (MessageGrouper._is_page_http_request(json_message) or message.log.message.startswith("slice:"))  # type: ignore[union-attr] # AirbyteMessage with MessageType.LOG has log.message
+            and (
+                MessageGrouper._is_page_http_request(json_message)
+                or message.log.message.startswith("slice:")
+            )  # type: ignore[union-attr] # AirbyteMessage with MessageType.LOG has log.message
         )
 
     @staticmethod
@@ -262,7 +319,9 @@ class MessageGrouper:
         if not json_message:
             return False
         else:
-            return MessageGrouper._is_http_log(json_message) and not MessageGrouper._is_auxiliary_http_request(json_message)
+            return MessageGrouper._is_http_log(
+                json_message
+            ) and not MessageGrouper._is_auxiliary_http_request(json_message)
 
     @staticmethod
     def _is_http_log(message: Dict[str, JsonType]) -> bool:
@@ -293,7 +352,11 @@ class MessageGrouper:
         Close a page when parsing message groups
         """
         current_slice_pages.append(
-            StreamReadPages(request=current_page_request, response=current_page_response, records=deepcopy(current_page_records))  # type: ignore
+            StreamReadPages(
+                request=current_page_request,
+                response=current_page_response,
+                records=deepcopy(current_page_records),
+            )  # type: ignore
         )
         current_page_records.clear()
 
@@ -307,7 +370,9 @@ class MessageGrouper:
         # the generator can raise an exception
         # iterate over the generated messages. if next raise an exception, catch it and yield it as an AirbyteLogMessage
         try:
-            yield from AirbyteEntrypoint(source).read(source.spec(self.logger), config, configured_catalog, state)
+            yield from AirbyteEntrypoint(source).read(
+                source.spec(self.logger), config, configured_catalog, state
+            )
         except AirbyteTracedException as traced_exception:
             # Look for this message which indicates that it is the "final exception" raised by AbstractSource.
             # If it matches, don't yield this as we don't need to show this in the Builder.
@@ -315,13 +380,16 @@ class MessageGrouper:
             # is that this message will be shown in the Builder.
             if (
                 traced_exception.message is not None
-                and "During the sync, the following streams did not sync successfully" in traced_exception.message
+                and "During the sync, the following streams did not sync successfully"
+                in traced_exception.message
             ):
                 return
             yield traced_exception.as_airbyte_message()
         except Exception as e:
             error_message = f"{e.args[0] if len(e.args) > 0 else str(e)}"
-            yield AirbyteTracedException.from_exception(e, message=error_message).as_airbyte_message()
+            yield AirbyteTracedException.from_exception(
+                e, message=error_message
+            ).as_airbyte_message()
 
     @staticmethod
     def _parse_json(log_message: AirbyteLogMessage) -> JsonType:
@@ -349,7 +417,9 @@ class MessageGrouper:
     def _create_response_from_log_message(json_http_message: Dict[str, Any]) -> HttpResponse:
         response = json_http_message.get("http", {}).get("response", {})
         body = response.get("body", {}).get("content", "")
-        return HttpResponse(status=response.get("status_code"), body=body, headers=response.get("headers"))
+        return HttpResponse(
+            status=response.get("status_code"), body=body, headers=response.get("headers")
+        )
 
     def _has_reached_limit(self, slices: List[StreamReadSlices]) -> bool:
         if len(slices) >= self._max_slices:

airbyte_cdk/destinations/destination.py

@@ -11,7 +11,13 @@ from typing import Any, Iterable, List, Mapping
 
 from airbyte_cdk.connector import Connector
 from airbyte_cdk.exception_handler import init_uncaught_exception_handler
-from airbyte_cdk.models import AirbyteMessage, AirbyteMessageSerializer, ConfiguredAirbyteCatalog, ConfiguredAirbyteCatalogSerializer, Type
+from airbyte_cdk.models import (
+    AirbyteMessage,
+    AirbyteMessageSerializer,
+    ConfiguredAirbyteCatalog,
+    ConfiguredAirbyteCatalogSerializer,
+    Type,
+)
 from airbyte_cdk.sources.utils.schema_helpers import check_config_against_spec_or_exit
 from airbyte_cdk.utils.traced_exception import AirbyteTracedException
 from orjson import orjson
@@ -24,7 +30,10 @@ class Destination(Connector, ABC):
 
     @abstractmethod
     def write(
-        self, config: Mapping[str, Any], configured_catalog: ConfiguredAirbyteCatalog, input_messages: Iterable[AirbyteMessage]
+        self,
+        config: Mapping[str, Any],
+        configured_catalog: ConfiguredAirbyteCatalog,
+        input_messages: Iterable[AirbyteMessage],
     ) -> Iterable[AirbyteMessage]:
         """Implement to define how the connector writes data to the destination"""
 
@@ -38,15 +47,24 @@ class Destination(Connector, ABC):
             try:
                 yield AirbyteMessageSerializer.load(orjson.loads(line))
             except orjson.JSONDecodeError:
-                logger.info(f"ignoring input which can't be deserialized as Airbyte Message: {line}")
+                logger.info(
+                    f"ignoring input which can't be deserialized as Airbyte Message: {line}"
+                )
 
     def _run_write(
-        self, config: Mapping[str, Any], configured_catalog_path: str, input_stream: io.TextIOWrapper
+        self,
+        config: Mapping[str, Any],
+        configured_catalog_path: str,
+        input_stream: io.TextIOWrapper,
     ) -> Iterable[AirbyteMessage]:
-        catalog = ConfiguredAirbyteCatalogSerializer.load(orjson.loads(open(configured_catalog_path).read()))
+        catalog = ConfiguredAirbyteCatalogSerializer.load(
+            orjson.loads(open(configured_catalog_path).read())
+        )
         input_messages = self._parse_input_stream(input_stream)
         logger.info("Begin writing to the destination...")
-        yield from self.write(config=config, configured_catalog=catalog, input_messages=input_messages)
+        yield from self.write(
+            config=config, configured_catalog=catalog, input_messages=input_messages
+        )
         logger.info("Writing complete.")
 
     def parse_args(self, args: List[str]) -> argparse.Namespace:
@@ -60,18 +78,30 @@ class Destination(Connector, ABC):
         subparsers = main_parser.add_subparsers(title="commands", dest="command")
 
         # spec
-        subparsers.add_parser("spec", help="outputs the json configuration specification", parents=[parent_parser])
+        subparsers.add_parser(
+            "spec", help="outputs the json configuration specification", parents=[parent_parser]
+        )
 
         # check
-        check_parser = subparsers.add_parser("check", help="checks the config can be used to connect", parents=[parent_parser])
+        check_parser = subparsers.add_parser(
+            "check", help="checks the config can be used to connect", parents=[parent_parser]
+        )
         required_check_parser = check_parser.add_argument_group("required named arguments")
-        required_check_parser.add_argument("--config", type=str, required=True, help="path to the json configuration file")
+        required_check_parser.add_argument(
+            "--config", type=str, required=True, help="path to the json configuration file"
+        )
 
         # write
-        write_parser = subparsers.add_parser("write", help="Writes data to the destination", parents=[parent_parser])
+        write_parser = subparsers.add_parser(
+            "write", help="Writes data to the destination", parents=[parent_parser]
+        )
         write_required = write_parser.add_argument_group("required named arguments")
-        write_required.add_argument("--config", type=str, required=True, help="path to the JSON configuration file")
-        write_required.add_argument("--catalog", type=str, required=True, help="path to the configured catalog JSON file")
+        write_required.add_argument(
+            "--config", type=str, required=True, help="path to the JSON configuration file"
+        )
+        write_required.add_argument(
+            "--catalog", type=str, required=True, help="path to the configured catalog JSON file"
+        )
 
         parsed_args = main_parser.parse_args(args)
         cmd = parsed_args.command
@@ -85,7 +115,6 @@ class Destination(Connector, ABC):
         return parsed_args
 
     def run_cmd(self, parsed_args: argparse.Namespace) -> Iterable[AirbyteMessage]:
-
         cmd = parsed_args.command
         if cmd not in self.VALID_CMDS:
             raise Exception(f"Unrecognized command: {cmd}")
@@ -110,7 +139,11 @@ class Destination(Connector, ABC):
         elif cmd == "write":
             # Wrap in UTF-8 to override any other input encodings
             wrapped_stdin = io.TextIOWrapper(sys.stdin.buffer, encoding="utf-8")
-            yield from self._run_write(config=config, configured_catalog_path=parsed_args.catalog, input_stream=wrapped_stdin)
+            yield from self._run_write(
+                config=config,
+                configured_catalog_path=parsed_args.catalog,
+                input_stream=wrapped_stdin,
+            )
 
     def run(self, args: List[str]) -> None:
         init_uncaught_exception_handler(logger)