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

airbyte_cdk/sources/declarative/requesters/request_options/interpolated_nested_request_input_provider.py

@@ -5,7 +5,10 @@
 from dataclasses import InitVar, dataclass, field
 from typing import Any, Mapping, Optional, Union
 
-from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import InterpolatedNestedMapping, NestedMapping
+from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import (
+    InterpolatedNestedMapping,
+    NestedMapping,
+)
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
@@ -19,16 +22,23 @@ class InterpolatedNestedRequestInputProvider:
     parameters: InitVar[Mapping[str, Any]]
     request_inputs: Optional[Union[str, NestedMapping]] = field(default=None)
     config: Config = field(default_factory=dict)
-    _interpolator: Optional[Union[InterpolatedString, InterpolatedNestedMapping]] = field(init=False, repr=False, default=None)
-    _request_inputs: Optional[Union[str, NestedMapping]] = field(init=False, repr=False, default=None)
+    _interpolator: Optional[Union[InterpolatedString, InterpolatedNestedMapping]] = field(
+        init=False, repr=False, default=None
+    )
+    _request_inputs: Optional[Union[str, NestedMapping]] = field(
+        init=False, repr=False, default=None
+    )
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-
         self._request_inputs = self.request_inputs or {}
         if isinstance(self._request_inputs, str):
-            self._interpolator = InterpolatedString(self._request_inputs, default="", parameters=parameters)
+            self._interpolator = InterpolatedString(
+                self._request_inputs, default="", parameters=parameters
+            )
         else:
-            self._interpolator = InterpolatedNestedMapping(self._request_inputs, parameters=parameters)
+            self._interpolator = InterpolatedNestedMapping(
+                self._request_inputs, parameters=parameters
+            )
 
     def eval_request_inputs(
         self,
@@ -44,5 +54,9 @@ class InterpolatedNestedRequestInputProvider:
         :param next_page_token: The pagination token
         :return: The request inputs to set on an outgoing HTTP request
         """
-        kwargs = {"stream_state": stream_state, "stream_slice": stream_slice, "next_page_token": next_page_token}
+        kwargs = {
+            "stream_state": stream_state,
+            "stream_slice": stream_slice,
+            "next_page_token": next_page_token,
+        }
         return self._interpolator.eval(self.config, **kwargs)  # type: ignore  # self._interpolator is always initialized with a value and will not be None

airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_input_provider.py

@@ -19,14 +19,19 @@ class InterpolatedRequestInputProvider:
     parameters: InitVar[Mapping[str, Any]]
     request_inputs: Optional[Union[str, Mapping[str, str]]] = field(default=None)
     config: Config = field(default_factory=dict)
-    _interpolator: Optional[Union[InterpolatedString, InterpolatedMapping]] = field(init=False, repr=False, default=None)
-    _request_inputs: Optional[Union[str, Mapping[str, str]]] = field(init=False, repr=False, default=None)
+    _interpolator: Optional[Union[InterpolatedString, InterpolatedMapping]] = field(
+        init=False, repr=False, default=None
+    )
+    _request_inputs: Optional[Union[str, Mapping[str, str]]] = field(
+        init=False, repr=False, default=None
+    )
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-
         self._request_inputs = self.request_inputs or {}
         if isinstance(self._request_inputs, str):
-            self._interpolator = InterpolatedString(self._request_inputs, default="", parameters=parameters)
+            self._interpolator = InterpolatedString(
+                self._request_inputs, default="", parameters=parameters
+            )
         else:
             self._interpolator = InterpolatedMapping(self._request_inputs, parameters=parameters)
 
@@ -48,9 +53,16 @@ class InterpolatedRequestInputProvider:
         :param valid_value_types: A tuple of types that the interpolator should allow
         :return: The request inputs to set on an outgoing HTTP request
         """
-        kwargs = {"stream_state": stream_state, "stream_slice": stream_slice, "next_page_token": next_page_token}
+        kwargs = {
+            "stream_state": stream_state,
+            "stream_slice": stream_slice,
+            "next_page_token": next_page_token,
+        }
         interpolated_value = self._interpolator.eval(  # type: ignore # self._interpolator is always initialized with a value and will not be None
-            self.config, valid_key_types=valid_key_types, valid_value_types=valid_value_types, **kwargs
+            self.config,
+            valid_key_types=valid_key_types,
+            valid_value_types=valid_value_types,
+            **kwargs,
         )
 
         if isinstance(interpolated_value, dict):

airbyte_cdk/sources/declarative/requesters/request_options/interpolated_request_options_provider.py

@@ -9,8 +9,12 @@ from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping i
 from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_nested_request_input_provider import (
     InterpolatedNestedRequestInputProvider,
 )
-from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_request_input_provider import InterpolatedRequestInputProvider
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
+from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_request_input_provider import (
+    InterpolatedRequestInputProvider,
+)
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
 from airbyte_cdk.sources.source import ExperimentalClassWarning
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 from deprecated import deprecated
@@ -50,7 +54,9 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
             self.request_body_json = {}
 
         if self.request_body_json and self.request_body_data:
-            raise ValueError("RequestOptionsProvider should only contain either 'request_body_data' or 'request_body_json' not both")
+            raise ValueError(
+                "RequestOptionsProvider should only contain either 'request_body_data' or 'request_body_json' not both"
+            )
 
         self._parameter_interpolator = InterpolatedRequestInputProvider(
             config=self.config, request_inputs=self.request_parameters, parameters=parameters
@@ -73,7 +79,11 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> MutableMapping[str, Any]:
         interpolated_value = self._parameter_interpolator.eval_request_inputs(
-            stream_state, stream_slice, next_page_token, valid_key_types=(str,), valid_value_types=ValidRequestTypes
+            stream_state,
+            stream_slice,
+            next_page_token,
+            valid_key_types=(str,),
+            valid_value_types=ValidRequestTypes,
         )
         if isinstance(interpolated_value, dict):
             return interpolated_value
@@ -86,7 +96,9 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, Any]:
-        return self._headers_interpolator.eval_request_inputs(stream_state, stream_slice, next_page_token)
+        return self._headers_interpolator.eval_request_inputs(
+            stream_state, stream_slice, next_page_token
+        )
 
     def get_request_body_data(
         self,
@@ -110,9 +122,14 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, Any]:
-        return self._body_json_interpolator.eval_request_inputs(stream_state, stream_slice, next_page_token)
+        return self._body_json_interpolator.eval_request_inputs(
+            stream_state, stream_slice, next_page_token
+        )
 
-    @deprecated("This class is temporary and used to incrementally deliver low-code to concurrent", category=ExperimentalClassWarning)
+    @deprecated(
+        "This class is temporary and used to incrementally deliver low-code to concurrent",
+        category=ExperimentalClassWarning,
+    )
     def request_options_contain_stream_state(self) -> bool:
         """
         Temporary helper method used as we move low-code streams to the concurrent framework. This method determines if
@@ -128,7 +145,9 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         )
 
     @staticmethod
-    def _check_if_interpolation_uses_stream_state(request_input: Optional[Union[RequestInput, NestedMapping]]) -> bool:
+    def _check_if_interpolation_uses_stream_state(
+        request_input: Optional[Union[RequestInput, NestedMapping]],
+    ) -> bool:
         if not request_input:
             return False
         elif isinstance(request_input, str):

airbyte_cdk/sources/declarative/requesters/requester.py

@@ -8,7 +8,9 @@ from typing import Any, Callable, Mapping, MutableMapping, Optional, Union
 
 import requests
 from airbyte_cdk.sources.declarative.auth.declarative_authenticator import DeclarativeAuthenticator
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
 from airbyte_cdk.sources.types import StreamSlice, StreamState
 
 

airbyte_cdk/sources/declarative/retrievers/async_retriever.py

@@ -5,7 +5,10 @@ from dataclasses import InitVar, dataclass, field
 from typing import Any, Callable, Iterable, Mapping, Optional
 
 from airbyte_cdk.models import FailureType
-from airbyte_cdk.sources.declarative.async_job.job_orchestrator import AsyncJobOrchestrator, AsyncPartition
+from airbyte_cdk.sources.declarative.async_job.job_orchestrator import (
+    AsyncJobOrchestrator,
+    AsyncPartition,
+)
 from airbyte_cdk.sources.declarative.extractors.record_selector import RecordSelector
 from airbyte_cdk.sources.declarative.partition_routers import SinglePartitionRouter
 from airbyte_cdk.sources.declarative.retrievers import Retriever
@@ -24,7 +27,9 @@ class AsyncRetriever(Retriever):
     parameters: InitVar[Mapping[str, Any]]
     job_orchestrator_factory: Callable[[Iterable[StreamSlice]], AsyncJobOrchestrator]
     record_selector: RecordSelector
-    stream_slicer: StreamSlicer = field(default_factory=lambda: SinglePartitionRouter(parameters={}))
+    stream_slicer: StreamSlicer = field(
+        default_factory=lambda: SinglePartitionRouter(parameters={})
+    )
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._job_orchestrator_factory = self.job_orchestrator_factory
@@ -66,7 +71,9 @@ class AsyncRetriever(Retriever):
 
         return self.state
 
-    def _validate_and_get_stream_slice_partition(self, stream_slice: Optional[StreamSlice] = None) -> AsyncPartition:
+    def _validate_and_get_stream_slice_partition(
+        self, stream_slice: Optional[StreamSlice] = None
+    ) -> AsyncPartition:
         """
         Validates the stream_slice argument and returns the partition from it.
 
@@ -93,7 +100,8 @@ class AsyncRetriever(Retriever):
 
         for completed_partition in self._job_orchestrator.create_and_get_completed_partitions():
             yield StreamSlice(
-                partition=dict(completed_partition.stream_slice.partition) | {"partition": completed_partition},
+                partition=dict(completed_partition.stream_slice.partition)
+                | {"partition": completed_partition},
                 cursor_slice=completed_partition.stream_slice.cursor_slice,
             )
 
@@ -102,7 +110,6 @@ class AsyncRetriever(Retriever):
         records_schema: Mapping[str, Any],
         stream_slice: Optional[StreamSlice] = None,
     ) -> Iterable[StreamData]:
-
         stream_state: StreamState = self._get_stream_state()
         partition: AsyncPartition = self._validate_and_get_stream_slice_partition(stream_slice)
         records: Iterable[Mapping[str, Any]] = self._job_orchestrator.fetch_records(partition)

airbyte_cdk/sources/declarative/retrievers/simple_retriever.py

@@ -6,7 +6,18 @@ import json
 from dataclasses import InitVar, dataclass, field
 from functools import partial
 from itertools import islice
-from typing import Any, Callable, Iterable, List, Mapping, MutableMapping, Optional, Set, Tuple, Union
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
 
 import requests
 from airbyte_cdk.models import AirbyteMessage
@@ -14,10 +25,15 @@ from airbyte_cdk.sources.declarative.extractors.http_selector import HttpSelecto
 from airbyte_cdk.sources.declarative.incremental import ResumableFullRefreshCursor
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
 from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
-from airbyte_cdk.sources.declarative.partition_routers.single_partition_router import SinglePartitionRouter
+from airbyte_cdk.sources.declarative.partition_routers.single_partition_router import (
+    SinglePartitionRouter,
+)
 from airbyte_cdk.sources.declarative.requesters.paginators.no_pagination import NoPagination
 from airbyte_cdk.sources.declarative.requesters.paginators.paginator import Paginator
-from airbyte_cdk.sources.declarative.requesters.request_options import DefaultRequestOptionsProvider, RequestOptionsProvider
+from airbyte_cdk.sources.declarative.requesters.request_options import (
+    DefaultRequestOptionsProvider,
+    RequestOptionsProvider,
+)
 from airbyte_cdk.sources.declarative.requesters.requester import Requester
 from airbyte_cdk.sources.declarative.retrievers.retriever import Retriever
 from airbyte_cdk.sources.declarative.stream_slicers.stream_slicer import StreamSlicer
@@ -62,8 +78,12 @@ class SimpleRetriever(Retriever):
     primary_key: Optional[Union[str, List[str], List[List[str]]]]
     _primary_key: str = field(init=False, repr=False, default="")
     paginator: Optional[Paginator] = None
-    stream_slicer: StreamSlicer = field(default_factory=lambda: SinglePartitionRouter(parameters={}))
-    request_option_provider: RequestOptionsProvider = field(default_factory=lambda: DefaultRequestOptionsProvider(parameters={}))
+    stream_slicer: StreamSlicer = field(
+        default_factory=lambda: SinglePartitionRouter(parameters={})
+    )
+    request_option_provider: RequestOptionsProvider = field(
+        default_factory=lambda: DefaultRequestOptionsProvider(parameters={})
+    )
     cursor: Optional[DeclarativeCursor] = None
     ignore_stream_slicer_parameters_on_paginated_requests: bool = False
 
@@ -73,7 +93,11 @@ class SimpleRetriever(Retriever):
         self._last_page_size: int = 0
         self._last_record: Optional[Record] = None
         self._parameters = parameters
-        self._name = InterpolatedString(self._name, parameters=parameters) if isinstance(self._name, str) else self._name
+        self._name = (
+            InterpolatedString(self._name, parameters=parameters)
+            if isinstance(self._name, str)
+            else self._name
+        )
 
         # This mapping is used during a resumable full refresh syncs to indicate whether a partition has started syncing
         # records. Partitions serve as the key and map to True if they already began processing records
@@ -84,7 +108,11 @@ class SimpleRetriever(Retriever):
         """
         :return: Stream name
         """
-        return str(self._name.eval(self.config)) if isinstance(self._name, InterpolatedString) else self._name
+        return (
+            str(self._name.eval(self.config))
+            if isinstance(self._name, InterpolatedString)
+            else self._name
+        )
 
     @name.setter
     def name(self, value: str) -> None:
@@ -118,10 +146,20 @@ class SimpleRetriever(Retriever):
         """
         # FIXME we should eventually remove the usage of stream_state as part of the interpolation
         mappings = [
-            paginator_method(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
+            paginator_method(
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
+            ),
         ]
         if not next_page_token or not self.ignore_stream_slicer_parameters_on_paginated_requests:
-            mappings.append(stream_slicer_method(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token))
+            mappings.append(
+                stream_slicer_method(
+                    stream_state=stream_state,
+                    stream_slice=stream_slice,
+                    next_page_token=next_page_token,
+                )
+            )
         return combine_mappings(mappings)
 
     def _request_headers(
@@ -271,20 +309,35 @@ class SimpleRetriever(Retriever):
         return self._paginator.next_page_token(response, self._last_page_size, self._last_record)
 
     def _fetch_next_page(
-        self, stream_state: Mapping[str, Any], stream_slice: StreamSlice, next_page_token: Optional[Mapping[str, Any]] = None
+        self,
+        stream_state: Mapping[str, Any],
+        stream_slice: StreamSlice,
+        next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Optional[requests.Response]:
         return self.requester.send_request(
             path=self._paginator_path(),
             stream_state=stream_state,
             stream_slice=stream_slice,
             next_page_token=next_page_token,
-            request_headers=self._request_headers(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
-            request_params=self._request_params(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
+            request_headers=self._request_headers(
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
+            ),
+            request_params=self._request_params(
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
+            ),
             request_body_data=self._request_body_data(
-                stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
             ),
             request_body_json=self._request_body_json(
-                stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
             ),
         )
 
@@ -323,10 +376,14 @@ class SimpleRetriever(Retriever):
         if not response:
             next_page_token: Mapping[str, Any] = {FULL_REFRESH_SYNC_COMPLETE_KEY: True}
         else:
-            next_page_token = self._next_page_token(response) or {FULL_REFRESH_SYNC_COMPLETE_KEY: True}
+            next_page_token = self._next_page_token(response) or {
+                FULL_REFRESH_SYNC_COMPLETE_KEY: True
+            }
 
         if self.cursor:
-            self.cursor.close_slice(StreamSlice(cursor_slice=next_page_token, partition=stream_slice.partition))
+            self.cursor.close_slice(
+                StreamSlice(cursor_slice=next_page_token, partition=stream_slice.partition)
+            )
 
         # Always return an empty generator just in case no records were ever yielded
         yield from []
@@ -383,7 +440,9 @@ class SimpleRetriever(Retriever):
                 # Latest record read, not necessarily within slice boundaries.
                 # TODO Remove once all custom components implement `observe` method.
                 # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
-                most_recent_record_from_slice = self._get_most_recent_record(most_recent_record_from_slice, current_record, _slice)
+                most_recent_record_from_slice = self._get_most_recent_record(
+                    most_recent_record_from_slice, current_record, _slice
+                )
                 yield stream_data
 
             if self.cursor:
@@ -391,13 +450,20 @@ class SimpleRetriever(Retriever):
         return
 
     def _get_most_recent_record(
-        self, current_most_recent: Optional[Record], current_record: Optional[Record], stream_slice: StreamSlice
+        self,
+        current_most_recent: Optional[Record],
+        current_record: Optional[Record],
+        stream_slice: StreamSlice,
     ) -> Optional[Record]:
         if self.cursor and current_record:
             if not current_most_recent:
                 return current_record
             else:
-                return current_most_recent if self.cursor.is_greater_than_or_equal(current_most_recent, current_record) else current_record
+                return (
+                    current_most_recent
+                    if self.cursor.is_greater_than_or_equal(current_most_recent, current_record)
+                    else current_record
+                )
         else:
             return None
 
@@ -482,20 +548,35 @@ class SimpleRetrieverTestReadDecorator(SimpleRetriever):
         return islice(super().stream_slices(), self.maximum_number_of_slices)
 
     def _fetch_next_page(
-        self, stream_state: Mapping[str, Any], stream_slice: StreamSlice, next_page_token: Optional[Mapping[str, Any]] = None
+        self,
+        stream_state: Mapping[str, Any],
+        stream_slice: StreamSlice,
+        next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Optional[requests.Response]:
         return self.requester.send_request(
             path=self._paginator_path(),
             stream_state=stream_state,
             stream_slice=stream_slice,
             next_page_token=next_page_token,
-            request_headers=self._request_headers(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
-            request_params=self._request_params(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
+            request_headers=self._request_headers(
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
+            ),
+            request_params=self._request_params(
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
+            ),
             request_body_data=self._request_body_data(
-                stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
             ),
             request_body_json=self._request_body_json(
-                stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
             ),
             log_formatter=lambda response: format_http_message(
                 response,

airbyte_cdk/sources/declarative/schema/default_schema_loader.py

@@ -41,5 +41,7 @@ class DefaultSchemaLoader(SchemaLoader):
             # A slight hack since we don't directly have the stream name. However, when building the default filepath we assume the
             # runtime options stores stream name 'name' so we'll do the same here
             stream_name = self._parameters.get("name", "")
-            logging.info(f"Could not find schema for stream {stream_name}, defaulting to the empty schema")
+            logging.info(
+                f"Could not find schema for stream {stream_name}, defaulting to the empty schema"
+            )
             return {}

airbyte_cdk/sources/declarative/spec/spec.py

@@ -5,7 +5,11 @@
 from dataclasses import InitVar, dataclass
 from typing import Any, Mapping, Optional
 
-from airbyte_cdk.models import AdvancedAuth, ConnectorSpecification, ConnectorSpecificationSerializer  # type: ignore [attr-defined]
+from airbyte_cdk.models import (
+    AdvancedAuth,
+    ConnectorSpecification,
+    ConnectorSpecificationSerializer,
+)  # type: ignore [attr-defined]
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import AuthFlow
 
 
@@ -29,7 +33,9 @@ class Spec:
         Returns the connector specification according the spec block defined in the low code connector manifest.
         """
 
-        obj: dict[str, Mapping[str, Any] | str | AdvancedAuth] = {"connectionSpecification": self.connection_specification}
+        obj: dict[str, Mapping[str, Any] | str | AdvancedAuth] = {
+            "connectionSpecification": self.connection_specification
+        }
 
         if self.documentation_url:
             obj["documentationUrl"] = self.documentation_url

airbyte_cdk/sources/declarative/stream_slicers/stream_slicer.py

@@ -6,7 +6,9 @@ from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Iterable
 
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
 from airbyte_cdk.sources.types import StreamSlice
 
 

airbyte_cdk/sources/declarative/transformations/add_fields.py

@@ -85,12 +85,16 @@ class AddFields(RecordTransformation):
 
     fields: List[AddedFieldDefinition]
     parameters: InitVar[Mapping[str, Any]]
-    _parsed_fields: List[ParsedAddFieldDefinition] = field(init=False, repr=False, default_factory=list)
+    _parsed_fields: List[ParsedAddFieldDefinition] = field(
+        init=False, repr=False, default_factory=list
+    )
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         for add_field in self.fields:
             if len(add_field.path) < 1:
-                raise ValueError(f"Expected a non-zero-length path for the AddFields transformation {add_field}")
+                raise ValueError(
+                    f"Expected a non-zero-length path for the AddFields transformation {add_field}"
+                )
 
             if not isinstance(add_field.value, InterpolatedString):
                 if not isinstance(add_field.value, str):
@@ -106,7 +110,12 @@ class AddFields(RecordTransformation):
                     )
             else:
                 self._parsed_fields.append(
-                    ParsedAddFieldDefinition(add_field.path, add_field.value, value_type=add_field.value_type, parameters={})
+                    ParsedAddFieldDefinition(
+                        add_field.path,
+                        add_field.value,
+                        value_type=add_field.value_type,
+                        parameters={},
+                    )
                 )
 
     def transform(

airbyte_cdk/sources/declarative/transformations/remove_fields.py

@@ -44,7 +44,9 @@ class RemoveFields(RecordTransformation):
     condition: str = ""
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-        self._filter_interpolator = InterpolatedBoolean(condition=self.condition, parameters=parameters)
+        self._filter_interpolator = InterpolatedBoolean(
+            condition=self.condition, parameters=parameters
+        )
 
     def transform(
         self,
@@ -63,7 +65,9 @@ class RemoveFields(RecordTransformation):
                 dpath.delete(
                     record,
                     pointer,
-                    afilter=(lambda x: self._filter_interpolator.eval(config or {}, property=x)) if self.condition else None,
+                    afilter=(lambda x: self._filter_interpolator.eval(config or {}, property=x))
+                    if self.condition
+                    else None,
                 )
             except dpath.exceptions.PathNotFound:
                 # if the (potentially nested) property does not exist, silently skip

airbyte_cdk/sources/declarative/types.py

@@ -4,7 +4,14 @@
 
 from __future__ import annotations
 
-from airbyte_cdk.sources.types import Config, ConnectionDefinition, FieldPointer, Record, StreamSlice, StreamState
+from airbyte_cdk.sources.types import (
+    Config,
+    ConnectionDefinition,
+    FieldPointer,
+    Record,
+    StreamSlice,
+    StreamState,
+)
 
 # Note: This package originally contained class definitions for low-code CDK types, but we promoted them into the Python CDK.
 # We've migrated connectors in the repository to reference the new location, but these assignments are used to retain backwards

airbyte_cdk/sources/declarative/yaml_declarative_source.py

@@ -7,7 +7,9 @@ from typing import Any, List, Mapping, Optional
 
 import yaml
 from airbyte_cdk.models import AirbyteStateMessage, ConfiguredAirbyteCatalog
-from airbyte_cdk.sources.declarative.concurrent_declarative_source import ConcurrentDeclarativeSource
+from airbyte_cdk.sources.declarative.concurrent_declarative_source import (
+    ConcurrentDeclarativeSource,
+)
 from airbyte_cdk.sources.types import ConnectionDefinition
 
 

airbyte_cdk/sources/embedded/base_integration.py

@@ -7,7 +7,11 @@ from typing import Generic, Iterable, Optional, TypeVar
 
 from airbyte_cdk.connector import TConfig
 from airbyte_cdk.models import AirbyteRecordMessage, AirbyteStateMessage, SyncMode, Type
-from airbyte_cdk.sources.embedded.catalog import create_configured_catalog, get_stream, get_stream_names
+from airbyte_cdk.sources.embedded.catalog import (
+    create_configured_catalog,
+    get_stream,
+    get_stream_names,
+)
 from airbyte_cdk.sources.embedded.runner import SourceRunner
 from airbyte_cdk.sources.embedded.tools import get_defined_id
 from airbyte_cdk.sources.utils.schema_helpers import check_config_against_spec_or_exit
@@ -31,11 +35,15 @@ class BaseEmbeddedIntegration(ABC, Generic[TConfig, TOutput]):
         """
         pass
 
-    def _load_data(self, stream_name: str, state: Optional[AirbyteStateMessage] = None) -> Iterable[TOutput]:
+    def _load_data(
+        self, stream_name: str, state: Optional[AirbyteStateMessage] = None
+    ) -> Iterable[TOutput]:
         catalog = self.source.discover(self.config)
         stream = get_stream(catalog, stream_name)
         if not stream:
-            raise ValueError(f"Stream {stream_name} not found, the following streams are available: {', '.join(get_stream_names(catalog))}")
+            raise ValueError(
+                f"Stream {stream_name} not found, the following streams are available: {', '.join(get_stream_names(catalog))}"
+            )
         if SyncMode.incremental not in stream.supported_sync_modes:
             configured_catalog = create_configured_catalog(stream, sync_mode=SyncMode.full_refresh)
         else:
@@ -43,7 +51,9 @@ class BaseEmbeddedIntegration(ABC, Generic[TConfig, TOutput]):
 
         for message in self.source.read(self.config, configured_catalog, state):
             if message.type == Type.RECORD:
-                output = self._handle_record(message.record, get_defined_id(stream, message.record.data))  # type: ignore[union-attr] # record has `data`
+                output = self._handle_record(
+                    message.record, get_defined_id(stream, message.record.data)
+                )  # type: ignore[union-attr] # record has `data`
                 if output:
                     yield output
             elif message.type is Type.STATE and message.state: