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

airbyte_cdk/sources/declarative/partition_routers/cartesian_product_stream_slicer.py

@@ -10,11 +10,15 @@ from dataclasses import InitVar, dataclass
 from typing import Any, Iterable, List, Mapping, Optional
 
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
-from airbyte_cdk.sources.declarative.partition_routers.substream_partition_router import SubstreamPartitionRouter
+from airbyte_cdk.sources.declarative.partition_routers.substream_partition_router import (
+    SubstreamPartitionRouter,
+)
 from airbyte_cdk.sources.types import StreamSlice, StreamState
 
 
-def check_for_substream_in_slicers(slicers: Iterable[PartitionRouter], log_warning: Callable[[str], None]) -> None:
+def check_for_substream_in_slicers(
+    slicers: Iterable[PartitionRouter], log_warning: Callable[[str], None]
+) -> None:
     """
     Recursively checks for the presence of SubstreamPartitionRouter within slicers.
     Logs a warning if a SubstreamPartitionRouter is found within a CartesianProductStreamSlicer.
@@ -69,7 +73,11 @@ class CartesianProductStreamSlicer(PartitionRouter):
         return dict(
             ChainMap(
                 *[  # type: ignore # ChainMap expects a MutableMapping[Never, Never] for reasons
-                    s.get_request_params(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+                    s.get_request_params(
+                        stream_state=stream_state,
+                        stream_slice=stream_slice,
+                        next_page_token=next_page_token,
+                    )
                     for s in self.stream_slicers
                 ]
             )
@@ -85,7 +93,11 @@ class CartesianProductStreamSlicer(PartitionRouter):
         return dict(
             ChainMap(
                 *[  # type: ignore # ChainMap expects a MutableMapping[Never, Never] for reasons
-                    s.get_request_headers(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+                    s.get_request_headers(
+                        stream_state=stream_state,
+                        stream_slice=stream_slice,
+                        next_page_token=next_page_token,
+                    )
                     for s in self.stream_slicers
                 ]
             )
@@ -101,7 +113,11 @@ class CartesianProductStreamSlicer(PartitionRouter):
         return dict(
             ChainMap(
                 *[  # type: ignore # ChainMap expects a MutableMapping[Never, Never] for reasons
-                    s.get_request_body_data(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+                    s.get_request_body_data(
+                        stream_state=stream_state,
+                        stream_slice=stream_slice,
+                        next_page_token=next_page_token,
+                    )
                     for s in self.stream_slicers
                 ]
             )
@@ -117,7 +133,11 @@ class CartesianProductStreamSlicer(PartitionRouter):
         return dict(
             ChainMap(
                 *[  # type: ignore # ChainMap expects a MutableMapping[Never, Never] for reasons
-                    s.get_request_body_json(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+                    s.get_request_body_json(
+                        stream_state=stream_state,
+                        stream_slice=stream_slice,
+                        next_page_token=next_page_token,
+                    )
                     for s in self.stream_slicers
                 ]
             )
@@ -130,7 +150,9 @@ class CartesianProductStreamSlicer(PartitionRouter):
             partition = dict(ChainMap(*[s.partition for s in stream_slice_tuple]))  # type: ignore # ChainMap expects a MutableMapping[Never, Never] for reasons
             cursor_slices = [s.cursor_slice for s in stream_slice_tuple if s.cursor_slice]
             if len(cursor_slices) > 1:
-                raise ValueError(f"There should only be a single cursor slice. Found {cursor_slices}")
+                raise ValueError(
+                    f"There should only be a single cursor slice. Found {cursor_slices}"
+                )
             if cursor_slices:
                 cursor_slice = cursor_slices[0]
             else:

airbyte_cdk/sources/declarative/partition_routers/list_partition_router.py

@@ -7,7 +7,10 @@ from typing import Any, Iterable, List, Mapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
-from airbyte_cdk.sources.declarative.requesters.request_option import RequestOption, RequestOptionType
+from airbyte_cdk.sources.declarative.requesters.request_option import (
+    RequestOption,
+    RequestOptionType,
+)
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
 
@@ -32,9 +35,13 @@ class ListPartitionRouter(PartitionRouter):
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         if isinstance(self.values, str):
-            self.values = InterpolatedString.create(self.values, parameters=parameters).eval(self.config)
+            self.values = InterpolatedString.create(self.values, parameters=parameters).eval(
+                self.config
+            )
         self._cursor_field = (
-            InterpolatedString(string=self.cursor_field, parameters=parameters) if isinstance(self.cursor_field, str) else self.cursor_field
+            InterpolatedString(string=self.cursor_field, parameters=parameters)
+            if isinstance(self.cursor_field, str)
+            else self.cursor_field
         )
 
         self._cursor = None
@@ -76,10 +83,21 @@ class ListPartitionRouter(PartitionRouter):
         return self._get_request_option(RequestOptionType.body_json, stream_slice)
 
     def stream_slices(self) -> Iterable[StreamSlice]:
-        return [StreamSlice(partition={self._cursor_field.eval(self.config): slice_value}, cursor_slice={}) for slice_value in self.values]
-
-    def _get_request_option(self, request_option_type: RequestOptionType, stream_slice: Optional[StreamSlice]) -> Mapping[str, Any]:
-        if self.request_option and self.request_option.inject_into == request_option_type and stream_slice:
+        return [
+            StreamSlice(
+                partition={self._cursor_field.eval(self.config): slice_value}, cursor_slice={}
+            )
+            for slice_value in self.values
+        ]
+
+    def _get_request_option(
+        self, request_option_type: RequestOptionType, stream_slice: Optional[StreamSlice]
+    ) -> Mapping[str, Any]:
+        if (
+            self.request_option
+            and self.request_option.inject_into == request_option_type
+            and stream_slice
+        ):
             slice_value = stream_slice.get(self._cursor_field.eval(self.config))
             if slice_value:
                 return {self.request_option.field_name.eval(self.config): slice_value}  # type: ignore # field_name is always casted to InterpolatedString

airbyte_cdk/sources/declarative/partition_routers/substream_partition_router.py

@@ -11,7 +11,10 @@ from airbyte_cdk.models import AirbyteMessage
 from airbyte_cdk.models import Type as MessageType
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
-from airbyte_cdk.sources.declarative.requesters.request_option import RequestOption, RequestOptionType
+from airbyte_cdk.sources.declarative.requesters.request_option import (
+    RequestOption,
+    RequestOptionType,
+)
 from airbyte_cdk.sources.types import Config, Record, StreamSlice, StreamState
 from airbyte_cdk.utils import AirbyteTracedException
 
@@ -37,17 +40,22 @@ class ParentStreamConfig:
     partition_field: Union[InterpolatedString, str]
     config: Config
     parameters: InitVar[Mapping[str, Any]]
-    extra_fields: Optional[Union[List[List[str]], List[List[InterpolatedString]]]] = None  # List of field paths (arrays of strings)
+    extra_fields: Optional[Union[List[List[str]], List[List[InterpolatedString]]]] = (
+        None  # List of field paths (arrays of strings)
+    )
     request_option: Optional[RequestOption] = None
     incremental_dependency: bool = False
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self.parent_key = InterpolatedString.create(self.parent_key, parameters=parameters)
-        self.partition_field = InterpolatedString.create(self.partition_field, parameters=parameters)
+        self.partition_field = InterpolatedString.create(
+            self.partition_field, parameters=parameters
+        )
         if self.extra_fields:
             # Create InterpolatedString for each field path in extra_keys
             self.extra_fields = [
-                [InterpolatedString.create(path, parameters=parameters) for path in key_path] for key_path in self.extra_fields
+                [InterpolatedString.create(path, parameters=parameters) for path in key_path]
+                for key_path in self.extra_fields
             ]
 
 
@@ -106,15 +114,26 @@ class SubstreamPartitionRouter(PartitionRouter):
         # Pass the stream_slice from the argument, not the cursor because the cursor is updated after processing the response
         return self._get_request_option(RequestOptionType.body_json, stream_slice)
 
-    def _get_request_option(self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]) -> Mapping[str, Any]:
+    def _get_request_option(
+        self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]
+    ) -> Mapping[str, Any]:
         params = {}
         if stream_slice:
             for parent_config in self.parent_stream_configs:
-                if parent_config.request_option and parent_config.request_option.inject_into == option_type:
+                if (
+                    parent_config.request_option
+                    and parent_config.request_option.inject_into == option_type
+                ):
                     key = parent_config.partition_field.eval(self.config)  # type: ignore # partition_field is always casted to an interpolated string
                     value = stream_slice.get(key)
                     if value:
-                        params.update({parent_config.request_option.field_name.eval(config=self.config): value})  # type: ignore # field_name is always casted to an interpolated string
+                        params.update(
+                            {
+                                parent_config.request_option.field_name.eval(
+                                    config=self.config
+                                ): value
+                            }
+                        )  # type: ignore # field_name is always casted to an interpolated string
         return params
 
     def stream_slices(self) -> Iterable[StreamSlice]:
@@ -141,7 +160,10 @@ class SubstreamPartitionRouter(PartitionRouter):
                 partition_field = parent_stream_config.partition_field.eval(self.config)  # type: ignore # partition_field is always casted to an interpolated string
                 extra_fields = None
                 if parent_stream_config.extra_fields:
-                    extra_fields = [[field_path_part.eval(self.config) for field_path_part in field_path] for field_path in parent_stream_config.extra_fields]  # type: ignore # extra_fields is always casted to an interpolated string
+                    extra_fields = [
+                        [field_path_part.eval(self.config) for field_path_part in field_path]
+                        for field_path in parent_stream_config.extra_fields
+                    ]  # type: ignore # extra_fields is always casted to an interpolated string
 
                 # read_stateless() assumes the parent is not concurrent. This is currently okay since the concurrent CDK does
                 # not support either substreams or RFR, but something that needs to be considered once we do
@@ -157,11 +179,17 @@ class SubstreamPartitionRouter(PartitionRouter):
                         else:
                             continue
                     elif isinstance(parent_record, Record):
-                        parent_partition = parent_record.associated_slice.partition if parent_record.associated_slice else {}
+                        parent_partition = (
+                            parent_record.associated_slice.partition
+                            if parent_record.associated_slice
+                            else {}
+                        )
                         parent_record = parent_record.data
                     elif not isinstance(parent_record, Mapping):
                         # The parent_record should only take the form of a Record, AirbyteMessage, or Mapping. Anything else is invalid
-                        raise AirbyteTracedException(message=f"Parent stream returned records as invalid type {type(parent_record)}")
+                        raise AirbyteTracedException(
+                            message=f"Parent stream returned records as invalid type {type(parent_record)}"
+                        )
                     try:
                         partition_value = dpath.get(parent_record, parent_field)
                     except KeyError:
@@ -171,13 +199,18 @@ class SubstreamPartitionRouter(PartitionRouter):
                     extracted_extra_fields = self._extract_extra_fields(parent_record, extra_fields)
 
                     yield StreamSlice(
-                        partition={partition_field: partition_value, "parent_slice": parent_partition or {}},
+                        partition={
+                            partition_field: partition_value,
+                            "parent_slice": parent_partition or {},
+                        },
                         cursor_slice={},
                         extra_fields=extracted_extra_fields,
                     )
 
     def _extract_extra_fields(
-        self, parent_record: Mapping[str, Any] | AirbyteMessage, extra_fields: Optional[List[List[str]]] = None
+        self,
+        parent_record: Mapping[str, Any] | AirbyteMessage,
+        extra_fields: Optional[List[List[str]]] = None,
     ) -> Mapping[str, Any]:
         """
         Extracts additional fields specified by their paths from the parent record.
@@ -195,7 +228,9 @@ class SubstreamPartitionRouter(PartitionRouter):
             for extra_field_path in extra_fields:
                 try:
                     extra_field_value = dpath.get(parent_record, extra_field_path)
-                    self.logger.debug(f"Extracted extra_field_path: {extra_field_path} with value: {extra_field_value}")
+                    self.logger.debug(
+                        f"Extracted extra_field_path: {extra_field_path} with value: {extra_field_value}"
+                    )
                 except KeyError:
                     self.logger.debug(f"Failed to extract extra_field_path: {extra_field_path}")
                     extra_field_value = None
@@ -246,7 +281,9 @@ class SubstreamPartitionRouter(PartitionRouter):
 
         # If `parent_state` doesn't exist and at least one parent stream has an incremental dependency,
         # copy the child state to parent streams with incremental dependencies.
-        incremental_dependency = any([parent_config.incremental_dependency for parent_config in self.parent_stream_configs])
+        incremental_dependency = any(
+            [parent_config.incremental_dependency for parent_config in self.parent_stream_configs]
+        )
         if not parent_state and not incremental_dependency:
             return
 
@@ -260,7 +297,9 @@ class SubstreamPartitionRouter(PartitionRouter):
             if substream_state:
                 for parent_config in self.parent_stream_configs:
                     if parent_config.incremental_dependency:
-                        parent_state[parent_config.stream.name] = {parent_config.stream.cursor_field: substream_state}
+                        parent_state[parent_config.stream.name] = {
+                            parent_config.stream.cursor_field: substream_state
+                        }
 
         # Set state for each parent stream with an incremental dependency
         for parent_config in self.parent_stream_configs:

airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/constant_backoff_strategy.py

@@ -28,9 +28,13 @@ class ConstantBackoffStrategy(BackoffStrategy):
         if not isinstance(self.backoff_time_in_seconds, InterpolatedString):
             self.backoff_time_in_seconds = str(self.backoff_time_in_seconds)
         if isinstance(self.backoff_time_in_seconds, float):
-            self.backoff_time_in_seconds = InterpolatedString.create(str(self.backoff_time_in_seconds), parameters=parameters)
+            self.backoff_time_in_seconds = InterpolatedString.create(
+                str(self.backoff_time_in_seconds), parameters=parameters
+            )
         else:
-            self.backoff_time_in_seconds = InterpolatedString.create(self.backoff_time_in_seconds, parameters=parameters)
+            self.backoff_time_in_seconds = InterpolatedString.create(
+                self.backoff_time_in_seconds, parameters=parameters
+            )
 
     def backoff_time(
         self,

airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/header_helper.py

@@ -9,7 +9,9 @@ from typing import Optional
 import requests
 
 
-def get_numeric_value_from_header(response: requests.Response, header: str, regex: Optional[Pattern[str]]) -> Optional[float]:
+def get_numeric_value_from_header(
+    response: requests.Response, header: str, regex: Optional[Pattern[str]]
+) -> Optional[float]:
     """
     Extract a header value from the response as a float
     :param response: response the extract header value from

airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/wait_time_from_header_backoff_strategy.py

@@ -9,8 +9,12 @@ from typing import Any, Mapping, Optional, Union
 import requests
 from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.header_helper import get_numeric_value_from_header
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategy import BackoffStrategy
+from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.header_helper import (
+    get_numeric_value_from_header,
+)
+from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategy import (
+    BackoffStrategy,
+)
 from airbyte_cdk.sources.types import Config
 from airbyte_cdk.utils import AirbyteTracedException
 
@@ -33,11 +37,15 @@ class WaitTimeFromHeaderBackoffStrategy(BackoffStrategy):
     max_waiting_time_in_seconds: Optional[float] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-        self.regex = InterpolatedString.create(self.regex, parameters=parameters) if self.regex else None
+        self.regex = (
+            InterpolatedString.create(self.regex, parameters=parameters) if self.regex else None
+        )
         self.header = InterpolatedString.create(self.header, parameters=parameters)
 
     def backoff_time(
-        self, response_or_exception: Optional[Union[requests.Response, requests.RequestException]], attempt_count: int
+        self,
+        response_or_exception: Optional[Union[requests.Response, requests.RequestException]],
+        attempt_count: int,
     ) -> Optional[float]:
         header = self.header.eval(config=self.config)  # type: ignore  # header is always cast to an interpolated stream
         if self.regex:
@@ -48,7 +56,11 @@ class WaitTimeFromHeaderBackoffStrategy(BackoffStrategy):
         header_value = None
         if isinstance(response_or_exception, requests.Response):
             header_value = get_numeric_value_from_header(response_or_exception, header, regex)
-            if self.max_waiting_time_in_seconds and header_value and header_value >= self.max_waiting_time_in_seconds:
+            if (
+                self.max_waiting_time_in_seconds
+                and header_value
+                and header_value >= self.max_waiting_time_in_seconds
+            ):
                 raise AirbyteTracedException(
                     internal_message=f"Rate limit wait time {header_value} is greater than max waiting time of {self.max_waiting_time_in_seconds} seconds. Stopping the stream...",
                     message="The rate limit is greater than max waiting time has been reached.",

airbyte_cdk/sources/declarative/requesters/error_handlers/backoff_strategies/wait_until_time_from_header_backoff_strategy.py

@@ -10,8 +10,12 @@ from typing import Any, Mapping, Optional, Union
 
 import requests
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.header_helper import get_numeric_value_from_header
-from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategy import BackoffStrategy
+from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategies.header_helper import (
+    get_numeric_value_from_header,
+)
+from airbyte_cdk.sources.declarative.requesters.error_handlers.backoff_strategy import (
+    BackoffStrategy,
+)
 from airbyte_cdk.sources.types import Config
 
 
@@ -35,12 +39,16 @@ class WaitUntilTimeFromHeaderBackoffStrategy(BackoffStrategy):
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self.header = InterpolatedString.create(self.header, parameters=parameters)
-        self.regex = InterpolatedString.create(self.regex, parameters=parameters) if self.regex else None
+        self.regex = (
+            InterpolatedString.create(self.regex, parameters=parameters) if self.regex else None
+        )
         if not isinstance(self.min_wait, InterpolatedString):
             self.min_wait = InterpolatedString.create(str(self.min_wait), parameters=parameters)
 
     def backoff_time(
-        self, response_or_exception: Optional[Union[requests.Response, requests.RequestException]], attempt_count: int
+        self,
+        response_or_exception: Optional[Union[requests.Response, requests.RequestException]],
+        attempt_count: int,
     ) -> Optional[float]:
         now = time.time()
         header = self.header.eval(self.config)  # type: ignore # header is always cast to an interpolated string
@@ -55,7 +63,9 @@ class WaitUntilTimeFromHeaderBackoffStrategy(BackoffStrategy):
         min_wait = self.min_wait.eval(self.config)  # type: ignore # header is always cast to an interpolated string
         if wait_until is None or not wait_until:
             return float(min_wait) if min_wait else None
-        if (isinstance(wait_until, str) and wait_until.isnumeric()) or isinstance(wait_until, numbers.Number):
+        if (isinstance(wait_until, str) and wait_until.isnumeric()) or isinstance(
+            wait_until, numbers.Number
+        ):
             wait_time = float(wait_until) - now
         else:
             return float(min_wait)

airbyte_cdk/sources/declarative/requesters/error_handlers/composite_error_handler.py

@@ -54,7 +54,9 @@ class CompositeErrorHandler(ErrorHandler):
     def max_time(self) -> Optional[int]:
         return max([error_handler.max_time or 0 for error_handler in self.error_handlers])
 
-    def interpret_response(self, response_or_exception: Optional[Union[requests.Response, Exception]]) -> ErrorResolution:
+    def interpret_response(
+        self, response_or_exception: Optional[Union[requests.Response, Exception]]
+    ) -> ErrorResolution:
         matched_error_resolution = None
         for error_handler in self.error_handlers:
             matched_error_resolution = error_handler.interpret_response(response_or_exception)

airbyte_cdk/sources/declarative/requesters/error_handlers/default_error_handler.py

@@ -6,8 +6,12 @@ from dataclasses import InitVar, dataclass, field
 from typing import Any, List, Mapping, MutableMapping, Optional, Union
 
 import requests
-from airbyte_cdk.sources.declarative.requesters.error_handlers.default_http_response_filter import DefaultHttpResponseFilter
-from airbyte_cdk.sources.declarative.requesters.error_handlers.http_response_filter import HttpResponseFilter
+from airbyte_cdk.sources.declarative.requesters.error_handlers.default_http_response_filter import (
+    DefaultHttpResponseFilter,
+)
+from airbyte_cdk.sources.declarative.requesters.error_handlers.http_response_filter import (
+    HttpResponseFilter,
+)
 from airbyte_cdk.sources.streams.http.error_handlers import BackoffStrategy, ErrorHandler
 from airbyte_cdk.sources.streams.http.error_handlers.response_models import (
     SUCCESS_RESOLUTION,
@@ -98,17 +102,19 @@ class DefaultErrorHandler(ErrorHandler):
     backoff_strategies: Optional[List[BackoffStrategy]] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-
         if not self.response_filters:
             self.response_filters = [HttpResponseFilter(config=self.config, parameters={})]
 
         self._last_request_to_attempt_count: MutableMapping[requests.PreparedRequest, int] = {}
 
-    def interpret_response(self, response_or_exception: Optional[Union[requests.Response, Exception]]) -> ErrorResolution:
-
+    def interpret_response(
+        self, response_or_exception: Optional[Union[requests.Response, Exception]]
+    ) -> ErrorResolution:
         if self.response_filters:
             for response_filter in self.response_filters:
-                matched_error_resolution = response_filter.matches(response_or_exception=response_or_exception)
+                matched_error_resolution = response_filter.matches(
+                    response_or_exception=response_or_exception
+                )
                 if matched_error_resolution:
                     return matched_error_resolution
         if isinstance(response_or_exception, requests.Response):
@@ -125,12 +131,16 @@ class DefaultErrorHandler(ErrorHandler):
         )
 
     def backoff_time(
-        self, response_or_exception: Optional[Union[requests.Response, requests.RequestException]], attempt_count: int = 0
+        self,
+        response_or_exception: Optional[Union[requests.Response, requests.RequestException]],
+        attempt_count: int = 0,
     ) -> Optional[float]:
         backoff = None
         if self.backoff_strategies:
             for backoff_strategy in self.backoff_strategies:
-                backoff = backoff_strategy.backoff_time(response_or_exception=response_or_exception, attempt_count=attempt_count)  # type: ignore # attempt_count maintained for compatibility with low code CDK
+                backoff = backoff_strategy.backoff_time(
+                    response_or_exception=response_or_exception, attempt_count=attempt_count
+                )  # type: ignore # attempt_count maintained for compatibility with low code CDK
                 if backoff:
                     return backoff
         return backoff

airbyte_cdk/sources/declarative/requesters/error_handlers/default_http_response_filter.py

@@ -5,18 +5,25 @@
 from typing import Optional, Union
 
 import requests
-from airbyte_cdk.sources.declarative.requesters.error_handlers.http_response_filter import HttpResponseFilter
-from airbyte_cdk.sources.streams.http.error_handlers.default_error_mapping import DEFAULT_ERROR_MAPPING
-from airbyte_cdk.sources.streams.http.error_handlers.response_models import ErrorResolution, create_fallback_error_resolution
+from airbyte_cdk.sources.declarative.requesters.error_handlers.http_response_filter import (
+    HttpResponseFilter,
+)
+from airbyte_cdk.sources.streams.http.error_handlers.default_error_mapping import (
+    DEFAULT_ERROR_MAPPING,
+)
+from airbyte_cdk.sources.streams.http.error_handlers.response_models import (
+    ErrorResolution,
+    create_fallback_error_resolution,
+)
 
 
 class DefaultHttpResponseFilter(HttpResponseFilter):
-    def matches(self, response_or_exception: Optional[Union[requests.Response, Exception]]) -> Optional[ErrorResolution]:
-
+    def matches(
+        self, response_or_exception: Optional[Union[requests.Response, Exception]]
+    ) -> Optional[ErrorResolution]:
         default_mapped_error_resolution = None
 
         if isinstance(response_or_exception, (requests.Response, Exception)):
-
             mapped_key: Union[int, type] = (
                 response_or_exception.status_code
                 if isinstance(response_or_exception, requests.Response)
@@ -26,5 +33,7 @@ class DefaultHttpResponseFilter(HttpResponseFilter):
             default_mapped_error_resolution = DEFAULT_ERROR_MAPPING.get(mapped_key)
 
         return (
-            default_mapped_error_resolution if default_mapped_error_resolution else create_fallback_error_resolution(response_or_exception)
+            default_mapped_error_resolution
+            if default_mapped_error_resolution
+            else create_fallback_error_resolution(response_or_exception)
         )

airbyte_cdk/sources/declarative/requesters/error_handlers/http_response_filter.py

@@ -10,8 +10,13 @@ from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
 from airbyte_cdk.sources.declarative.interpolation.interpolated_boolean import InterpolatedBoolean
 from airbyte_cdk.sources.streams.http.error_handlers import JsonErrorMessageParser
-from airbyte_cdk.sources.streams.http.error_handlers.default_error_mapping import DEFAULT_ERROR_MAPPING
-from airbyte_cdk.sources.streams.http.error_handlers.response_models import ErrorResolution, ResponseAction
+from airbyte_cdk.sources.streams.http.error_handlers.default_error_mapping import (
+    DEFAULT_ERROR_MAPPING,
+)
+from airbyte_cdk.sources.streams.http.error_handlers.response_models import (
+    ErrorResolution,
+    ResponseAction,
+)
 from airbyte_cdk.sources.types import Config
 
 
@@ -42,24 +47,35 @@ class HttpResponseFilter:
     error_message: Union[InterpolatedString, str] = ""
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-
         if self.action is not None:
-            if self.http_codes is None and self.predicate is None and self.error_message_contains is None:
-                raise ValueError("HttpResponseFilter requires a filter condition if an action is specified")
+            if (
+                self.http_codes is None
+                and self.predicate is None
+                and self.error_message_contains is None
+            ):
+                raise ValueError(
+                    "HttpResponseFilter requires a filter condition if an action is specified"
+                )
             elif isinstance(self.action, str):
                 self.action = ResponseAction[self.action]
         self.http_codes = self.http_codes or set()
         if isinstance(self.predicate, str):
             self.predicate = InterpolatedBoolean(condition=self.predicate, parameters=parameters)
-        self.error_message = InterpolatedString.create(string_or_interpolated=self.error_message, parameters=parameters)
+        self.error_message = InterpolatedString.create(
+            string_or_interpolated=self.error_message, parameters=parameters
+        )
         self._error_message_parser = JsonErrorMessageParser()
         if self.failure_type and isinstance(self.failure_type, str):
             self.failure_type = FailureType[self.failure_type]
 
-    def matches(self, response_or_exception: Optional[Union[requests.Response, Exception]]) -> Optional[ErrorResolution]:
+    def matches(
+        self, response_or_exception: Optional[Union[requests.Response, Exception]]
+    ) -> Optional[ErrorResolution]:
         filter_action = self._matches_filter(response_or_exception)
         mapped_key = (
-            response_or_exception.status_code if isinstance(response_or_exception, requests.Response) else response_or_exception.__class__
+            response_or_exception.status_code
+            if isinstance(response_or_exception, requests.Response)
+            else response_or_exception.__class__
         )
 
         if isinstance(mapped_key, (int, Exception)):
@@ -68,7 +84,11 @@ class HttpResponseFilter:
             default_mapped_error_resolution = None
 
         if filter_action is not None:
-            default_error_message = default_mapped_error_resolution.error_message if default_mapped_error_resolution else ""
+            default_error_message = (
+                default_mapped_error_resolution.error_message
+                if default_mapped_error_resolution
+                else ""
+            )
             error_message = None
             if isinstance(response_or_exception, requests.Response):
                 error_message = self._create_error_message(response_or_exception)
@@ -96,10 +116,14 @@ class HttpResponseFilter:
 
         return None
 
-    def _match_default_error_mapping(self, mapped_key: Union[int, type[Exception]]) -> Optional[ErrorResolution]:
+    def _match_default_error_mapping(
+        self, mapped_key: Union[int, type[Exception]]
+    ) -> Optional[ErrorResolution]:
         return DEFAULT_ERROR_MAPPING.get(mapped_key)
 
-    def _matches_filter(self, response_or_exception: Optional[Union[requests.Response, Exception]]) -> Optional[ResponseAction]:
+    def _matches_filter(
+        self, response_or_exception: Optional[Union[requests.Response, Exception]]
+    ) -> Optional[ResponseAction]:
         """
         Apply the HTTP filter on the response and return the action to execute if it matches
         :param response: The HTTP response to evaluate
@@ -126,14 +150,27 @@ class HttpResponseFilter:
         :param response: The HTTP response which can be used during interpolation
         :return: The evaluated error message string to be emitted
         """
-        return self.error_message.eval(self.config, response=self._safe_response_json(response), headers=response.headers)  # type: ignore # error_message is always cast to an interpolated string
+        return self.error_message.eval(
+            self.config, response=self._safe_response_json(response), headers=response.headers
+        )  # type: ignore # error_message is always cast to an interpolated string
 
     def _response_matches_predicate(self, response: requests.Response) -> bool:
-        return bool(self.predicate.condition and self.predicate.eval(None, response=self._safe_response_json(response), headers=response.headers)) if self.predicate else False  # type: ignore # predicate is always cast to an interpolated string
+        return (
+            bool(
+                self.predicate.condition
+                and self.predicate.eval(
+                    None, response=self._safe_response_json(response), headers=response.headers
+                )
+            )
+            if self.predicate
+            else False
+        )  # type: ignore # predicate is always cast to an interpolated string
 
     def _response_contains_error_message(self, response: requests.Response) -> bool:
         if not self.error_message_contains:
             return False
         else:
-            error_message = self._error_message_parser.parse_response_error_message(response=response)
+            error_message = self._error_message_parser.parse_response_error_message(
+                response=response
+            )
             return bool(error_message and self.error_message_contains in error_message)