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

airbyte_cdk/sources/declarative/extractors/record_selector.py

@@ -61,7 +61,9 @@ class RecordSelector(HttpSelector):
         :return: List of Records selected from the response
         """
         all_data: Iterable[Mapping[str, Any]] = self.extractor.extract_records(response)
-        yield from self.filter_and_transform(all_data, stream_state, records_schema, stream_slice, next_page_token)
+        yield from self.filter_and_transform(
+            all_data, stream_state, records_schema, stream_slice, next_page_token
+        )
 
     def filter_and_transform(
         self,
@@ -106,7 +108,10 @@ class RecordSelector(HttpSelector):
     ) -> Iterable[Mapping[str, Any]]:
         if self.record_filter:
             yield from self.record_filter.filter_records(
-                records, stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+                records,
+                stream_state=stream_state,
+                stream_slice=stream_slice,
+                next_page_token=next_page_token,
             )
         else:
             yield from records
@@ -119,5 +124,7 @@ class RecordSelector(HttpSelector):
     ) -> Iterable[Mapping[str, Any]]:
         for record in records:
             for transformation in self.transformations:
-                transformation.transform(record, config=self.config, stream_state=stream_state, stream_slice=stream_slice)  # type: ignore  # record has type Mapping[str, Any], but Dict[str, Any] expected
+                transformation.transform(
+                    record, config=self.config, stream_state=stream_state, stream_slice=stream_slice
+                )  # type: ignore  # record has type Mapping[str, Any], but Dict[str, Any] expected
             yield record

airbyte_cdk/sources/declarative/extractors/response_to_file_extractor.py

@@ -68,7 +68,9 @@ class ResponseToFileExtractor(RecordExtractor):
 
         res = b.replace(b"\x00", b"")
         if len(res) < len(b):
-            self.logger.warning("Filter 'null' bytes from string, size reduced %d -> %d chars", len(b), len(res))
+            self.logger.warning(
+                "Filter 'null' bytes from string, size reduced %d -> %d chars", len(b), len(res)
+            )
         return res
 
     def _save_to_file(self, response: requests.Response) -> Tuple[str, str]:
@@ -106,9 +108,13 @@ class ResponseToFileExtractor(RecordExtractor):
         if os.path.isfile(tmp_file):
             return tmp_file, response_encoding
         else:
-            raise ValueError(f"The IO/Error occured while verifying binary data. Tmp file {tmp_file} doesn't exist.")
+            raise ValueError(
+                f"The IO/Error occured while verifying binary data. Tmp file {tmp_file} doesn't exist."
+            )
 
-    def _read_with_chunks(self, path: str, file_encoding: str, chunk_size: int = 100) -> Iterable[Mapping[str, Any]]:
+    def _read_with_chunks(
+        self, path: str, file_encoding: str, chunk_size: int = 100
+    ) -> Iterable[Mapping[str, Any]]:
         """
         Reads data from a file in chunks and yields each row as a dictionary.
 
@@ -126,7 +132,9 @@ class ResponseToFileExtractor(RecordExtractor):
 
         try:
             with open(path, "r", encoding=file_encoding) as data:
-                chunks = pd.read_csv(data, chunksize=chunk_size, iterator=True, dialect="unix", dtype=object)
+                chunks = pd.read_csv(
+                    data, chunksize=chunk_size, iterator=True, dialect="unix", dtype=object
+                )
                 for chunk in chunks:
                     chunk = chunk.replace({nan: None}).to_dict(orient="records")
                     for row in chunk:
@@ -140,7 +148,9 @@ class ResponseToFileExtractor(RecordExtractor):
             # remove binary tmp file, after data is read
             os.remove(path)
 
-    def extract_records(self, response: Optional[requests.Response] = None) -> Iterable[Mapping[str, Any]]:
+    def extract_records(
+        self, response: Optional[requests.Response] = None
+    ) -> Iterable[Mapping[str, Any]]:
         """
         Extracts records from the given response by:
             1) Saving the result to a tmp file

airbyte_cdk/sources/declarative/incremental/datetime_based_cursor.py

@@ -13,7 +13,10 @@ from airbyte_cdk.sources.declarative.datetime.min_max_datetime import MinMaxDate
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.declarative.interpolation.jinja import JinjaInterpolation
-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.message import MessageRepository
 from airbyte_cdk.sources.types import Config, Record, StreamSlice, StreamState
 from isodate import Duration, duration_isoformat, parse_duration
@@ -72,27 +75,41 @@ class DatetimeBasedCursor(DeclarativeCursor):
     cursor_datetime_formats: List[str] = field(default_factory=lambda: [])
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-        if (self.step and not self.cursor_granularity) or (not self.step and self.cursor_granularity):
+        if (self.step and not self.cursor_granularity) or (
+            not self.step and self.cursor_granularity
+        ):
             raise ValueError(
                 f"If step is defined, cursor_granularity should be as well and vice-versa. "
                 f"Right now, step is `{self.step}` and cursor_granularity is `{self.cursor_granularity}`"
             )
         self._start_datetime = MinMaxDatetime.create(self.start_datetime, parameters)
-        self._end_datetime = None if not self.end_datetime else MinMaxDatetime.create(self.end_datetime, parameters)
+        self._end_datetime = (
+            None if not self.end_datetime else MinMaxDatetime.create(self.end_datetime, parameters)
+        )
 
         self._timezone = datetime.timezone.utc
         self._interpolation = JinjaInterpolation()
 
         self._step = (
-            self._parse_timedelta(InterpolatedString.create(self.step, parameters=parameters).eval(self.config))
+            self._parse_timedelta(
+                InterpolatedString.create(self.step, parameters=parameters).eval(self.config)
+            )
             if self.step
             else datetime.timedelta.max
         )
         self._cursor_granularity = self._parse_timedelta(self.cursor_granularity)
         self.cursor_field = InterpolatedString.create(self.cursor_field, parameters=parameters)
-        self._lookback_window = InterpolatedString.create(self.lookback_window, parameters=parameters) if self.lookback_window else None
-        self._partition_field_start = InterpolatedString.create(self.partition_field_start or "start_time", parameters=parameters)
-        self._partition_field_end = InterpolatedString.create(self.partition_field_end or "end_time", parameters=parameters)
+        self._lookback_window = (
+            InterpolatedString.create(self.lookback_window, parameters=parameters)
+            if self.lookback_window
+            else None
+        )
+        self._partition_field_start = InterpolatedString.create(
+            self.partition_field_start or "start_time", parameters=parameters
+        )
+        self._partition_field_end = InterpolatedString.create(
+            self.partition_field_end or "end_time", parameters=parameters
+        )
         self._parser = DatetimeParser()
 
         # If datetime format is not specified then start/end datetime should inherit it from the stream slicer
@@ -114,7 +131,9 @@ class DatetimeBasedCursor(DeclarativeCursor):
 
         :param stream_state: The state of the stream as returned by get_stream_state
         """
-        self._cursor = stream_state.get(self.cursor_field.eval(self.config)) if stream_state else None  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
+        self._cursor = (
+            stream_state.get(self.cursor_field.eval(self.config)) if stream_state else None
+        )  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
 
     def observe(self, stream_slice: StreamSlice, record: Record) -> None:
         """
@@ -131,28 +150,38 @@ class DatetimeBasedCursor(DeclarativeCursor):
 
         start_field = self._partition_field_start.eval(self.config)
         end_field = self._partition_field_end.eval(self.config)
-        is_highest_observed_cursor_value = not self._highest_observed_cursor_field_value or self.parse_date(
-            record_cursor_value
-        ) > self.parse_date(self._highest_observed_cursor_field_value)
+        is_highest_observed_cursor_value = (
+            not self._highest_observed_cursor_field_value
+            or self.parse_date(record_cursor_value)
+            > self.parse_date(self._highest_observed_cursor_field_value)
+        )
         if (
-            self._is_within_daterange_boundaries(record, stream_slice.get(start_field), stream_slice.get(end_field))  # type: ignore # we know that stream_slices for these cursors will use a string representing an unparsed date
+            self._is_within_daterange_boundaries(
+                record, stream_slice.get(start_field), stream_slice.get(end_field)
+            )  # type: ignore # we know that stream_slices for these cursors will use a string representing an unparsed date
             and is_highest_observed_cursor_value
         ):
             self._highest_observed_cursor_field_value = record_cursor_value
 
     def close_slice(self, stream_slice: StreamSlice, *args: Any) -> None:
         if stream_slice.partition:
-            raise ValueError(f"Stream slice {stream_slice} should not have a partition. Got {stream_slice.partition}.")
+            raise ValueError(
+                f"Stream slice {stream_slice} should not have a partition. Got {stream_slice.partition}."
+            )
         cursor_value_str_by_cursor_value_datetime = dict(
             map(
                 # we need to ensure the cursor value is preserved as is in the state else the CATs might complain of something like
                 # 2023-01-04T17:30:19.000Z' <= '2023-01-04T17:30:19.000000Z'
                 lambda datetime_str: (self.parse_date(datetime_str), datetime_str),  # type: ignore # because of the filter on the next line, this will only be called with a str
-                filter(lambda item: item, [self._cursor, self._highest_observed_cursor_field_value]),
+                filter(
+                    lambda item: item, [self._cursor, self._highest_observed_cursor_field_value]
+                ),
             )
         )
         self._cursor = (
-            cursor_value_str_by_cursor_value_datetime[max(cursor_value_str_by_cursor_value_datetime.keys())]
+            cursor_value_str_by_cursor_value_datetime[
+                max(cursor_value_str_by_cursor_value_datetime.keys())
+            ]
             if cursor_value_str_by_cursor_value_datetime
             else None
         )
@@ -175,11 +204,19 @@ class DatetimeBasedCursor(DeclarativeCursor):
         # through each slice and does not belong to a specific slice. We just return stream state as it is.
         return self.get_stream_state()
 
-    def _calculate_earliest_possible_value(self, end_datetime: datetime.datetime) -> datetime.datetime:
-        lookback_delta = self._parse_timedelta(self._lookback_window.eval(self.config) if self._lookback_window else "P0D")
-        earliest_possible_start_datetime = min(self._start_datetime.get_datetime(self.config), end_datetime)
+    def _calculate_earliest_possible_value(
+        self, end_datetime: datetime.datetime
+    ) -> datetime.datetime:
+        lookback_delta = self._parse_timedelta(
+            self._lookback_window.eval(self.config) if self._lookback_window else "P0D"
+        )
+        earliest_possible_start_datetime = min(
+            self._start_datetime.get_datetime(self.config), end_datetime
+        )
         try:
-            cursor_datetime = self._calculate_cursor_datetime_from_state(self.get_stream_state()) - lookback_delta
+            cursor_datetime = (
+                self._calculate_cursor_datetime_from_state(self.get_stream_state()) - lookback_delta
+            )
         except OverflowError:
             # cursor_datetime defers to the minimum date if it does not exist in the state. Trying to subtract
             # a timedelta from the minimum datetime results in an OverflowError
@@ -200,7 +237,9 @@ class DatetimeBasedCursor(DeclarativeCursor):
             return now
         return min(self._end_datetime.get_datetime(self.config), now)
 
-    def _calculate_cursor_datetime_from_state(self, stream_state: Mapping[str, Any]) -> datetime.datetime:
+    def _calculate_cursor_datetime_from_state(
+        self, stream_state: Mapping[str, Any]
+    ) -> datetime.datetime:
         if self.cursor_field.eval(self.config, stream_state=stream_state) in stream_state:  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
             return self.parse_date(stream_state[self.cursor_field.eval(self.config)])  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
         return datetime.datetime.min.replace(tzinfo=datetime.timezone.utc)
@@ -209,7 +248,10 @@ class DatetimeBasedCursor(DeclarativeCursor):
         return self._parser.format(dt, self.datetime_format)
 
     def _partition_daterange(
-        self, start: datetime.datetime, end: datetime.datetime, step: Union[datetime.timedelta, Duration]
+        self,
+        start: datetime.datetime,
+        end: datetime.datetime,
+        step: Union[datetime.timedelta, Duration],
     ) -> List[StreamSlice]:
         start_field = self._partition_field_start.eval(self.config)
         end_field = self._partition_field_end.eval(self.config)
@@ -220,7 +262,11 @@ class DatetimeBasedCursor(DeclarativeCursor):
             end_date = self._get_date(next_start - self._cursor_granularity, end, min)
             dates.append(
                 StreamSlice(
-                    partition={}, cursor_slice={start_field: self._format_datetime(start), end_field: self._format_datetime(end_date)}
+                    partition={},
+                    cursor_slice={
+                        start_field: self._format_datetime(start),
+                        end_field: self._format_datetime(end_date),
+                    },
                 )
             )
             start = next_start
@@ -231,7 +277,9 @@ class DatetimeBasedCursor(DeclarativeCursor):
             return start < end
         return start <= end
 
-    def _evaluate_next_start_date_safely(self, start: datetime.datetime, step: datetime.timedelta) -> datetime.datetime:
+    def _evaluate_next_start_date_safely(
+        self, start: datetime.datetime, step: datetime.timedelta
+    ) -> datetime.datetime:
         """
         Given that we set the default step at datetime.timedelta.max, we will generate an OverflowError when evaluating the next start_date
         This method assumes that users would never enter a step that would generate an overflow. Given that would be the case, the code
@@ -308,7 +356,9 @@ class DatetimeBasedCursor(DeclarativeCursor):
         # Never update kwargs
         return {}
 
-    def _get_request_options(self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]) -> Mapping[str, Any]:
+    def _get_request_options(
+        self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]
+    ) -> Mapping[str, Any]:
         options: MutableMapping[str, Any] = {}
         if not stream_slice:
             return options
@@ -317,7 +367,9 @@ class DatetimeBasedCursor(DeclarativeCursor):
                 self._partition_field_start.eval(self.config)
             )
         if self.end_time_option and self.end_time_option.inject_into == option_type:
-            options[self.end_time_option.field_name.eval(config=self.config)] = stream_slice.get(self._partition_field_end.eval(self.config))  # type: ignore # field_name is always casted to an interpolated string
+            options[self.end_time_option.field_name.eval(config=self.config)] = stream_slice.get(
+                self._partition_field_end.eval(self.config)
+            )  # type: ignore # field_name is always casted to an interpolated string
         return options
 
     def should_be_synced(self, record: Record) -> bool:
@@ -330,11 +382,18 @@ class DatetimeBasedCursor(DeclarativeCursor):
             )
             return True
         latest_possible_cursor_value = self.select_best_end_datetime()
-        earliest_possible_cursor_value = self._calculate_earliest_possible_value(latest_possible_cursor_value)
-        return self._is_within_daterange_boundaries(record, earliest_possible_cursor_value, latest_possible_cursor_value)
+        earliest_possible_cursor_value = self._calculate_earliest_possible_value(
+            latest_possible_cursor_value
+        )
+        return self._is_within_daterange_boundaries(
+            record, earliest_possible_cursor_value, latest_possible_cursor_value
+        )
 
     def _is_within_daterange_boundaries(
-        self, record: Record, start_datetime_boundary: Union[datetime.datetime, str], end_datetime_boundary: Union[datetime.datetime, str]
+        self,
+        record: Record,
+        start_datetime_boundary: Union[datetime.datetime, str],
+        end_datetime_boundary: Union[datetime.datetime, str],
     ) -> bool:
         cursor_field = self.cursor_field.eval(self.config)  # type: ignore  # cursor_field is converted to an InterpolatedString in __post_init__
         record_cursor_value = record.get(cursor_field)
@@ -348,7 +407,9 @@ class DatetimeBasedCursor(DeclarativeCursor):
             start_datetime_boundary = self.parse_date(start_datetime_boundary)
         if isinstance(end_datetime_boundary, str):
             end_datetime_boundary = self.parse_date(end_datetime_boundary)
-        return start_datetime_boundary <= self.parse_date(record_cursor_value) <= end_datetime_boundary
+        return (
+            start_datetime_boundary <= self.parse_date(record_cursor_value) <= end_datetime_boundary
+        )
 
     def _send_log(self, level: Level, message: str) -> None:
         if self.message_repository:
@@ -378,8 +439,12 @@ class DatetimeBasedCursor(DeclarativeCursor):
         :param lookback_window_in_seconds: The lookback duration in seconds to potentially update to.
         """
         runtime_lookback_window = duration_isoformat(timedelta(seconds=lookback_window_in_seconds))
-        config_lookback = parse_duration(self._lookback_window.eval(self.config) if self._lookback_window else "P0D")
+        config_lookback = parse_duration(
+            self._lookback_window.eval(self.config) if self._lookback_window else "P0D"
+        )
 
         # Check if the new runtime lookback window is greater than the current config lookback
         if parse_duration(runtime_lookback_window) > config_lookback:
-            self._lookback_window = InterpolatedString.create(runtime_lookback_window, parameters={})
+            self._lookback_window = InterpolatedString.create(
+                runtime_lookback_window, parameters={}
+            )

airbyte_cdk/sources/declarative/incremental/global_substream_cursor.py

@@ -84,7 +84,9 @@ class GlobalSubstreamCursor(DeclarativeCursor):
         self._partition_router = partition_router
         self._timer = Timer()
         self._lock = threading.Lock()
-        self._slice_semaphore = threading.Semaphore(0)  # Start with 0, indicating no slices being tracked
+        self._slice_semaphore = threading.Semaphore(
+            0
+        )  # Start with 0, indicating no slices being tracked
         self._all_slices_yielded = False
         self._lookback_window: Optional[int] = None
         self._current_partition: Optional[Mapping[str, Any]] = None
@@ -116,7 +118,9 @@ class GlobalSubstreamCursor(DeclarativeCursor):
         )
 
         self.start_slices_generation()
-        for slice, last, state in iterate_with_last_flag_and_state(slice_generator, self._partition_router.get_stream_state):
+        for slice, last, state in iterate_with_last_flag_and_state(
+            slice_generator, self._partition_router.get_stream_state
+        ):
             self._parent_state = state
             self.register_slice(last)
             yield slice
@@ -124,7 +128,8 @@ class GlobalSubstreamCursor(DeclarativeCursor):
 
     def generate_slices_from_partition(self, partition: StreamSlice) -> Iterable[StreamSlice]:
         slice_generator = (
-            StreamSlice(partition=partition, cursor_slice=cursor_slice) for cursor_slice in self._stream_cursor.stream_slices()
+            StreamSlice(partition=partition, cursor_slice=cursor_slice)
+            for cursor_slice in self._stream_cursor.stream_slices()
         )
 
         yield from slice_generator
@@ -199,10 +204,14 @@ class GlobalSubstreamCursor(DeclarativeCursor):
         if hasattr(self._stream_cursor, "set_runtime_lookback_window"):
             self._stream_cursor.set_runtime_lookback_window(lookback_window)
         else:
-            raise ValueError("The cursor class for Global Substream Cursor does not have a set_runtime_lookback_window method")
+            raise ValueError(
+                "The cursor class for Global Substream Cursor does not have a set_runtime_lookback_window method"
+            )
 
     def observe(self, stream_slice: StreamSlice, record: Record) -> None:
-        self._stream_cursor.observe(StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice), record)
+        self._stream_cursor.observe(
+            StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice), record
+        )
 
     def close_slice(self, stream_slice: StreamSlice, *args: Any) -> None:
         """
@@ -220,7 +229,9 @@ class GlobalSubstreamCursor(DeclarativeCursor):
             self._slice_semaphore.acquire()
             if self._all_slices_yielded and self._slice_semaphore._value == 0:
                 self._lookback_window = self._timer.finish()
-                self._stream_cursor.close_slice(StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice), *args)
+                self._stream_cursor.close_slice(
+                    StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice), *args
+                )
 
     def get_stream_state(self) -> StreamState:
         state: dict[str, Any] = {"state": self._stream_cursor.get_stream_state()}
@@ -322,12 +333,15 @@ class GlobalSubstreamCursor(DeclarativeCursor):
 
     def is_greater_than_or_equal(self, first: Record, second: Record) -> bool:
         return self._stream_cursor.is_greater_than_or_equal(
-            self._convert_record_to_cursor_record(first), self._convert_record_to_cursor_record(second)
+            self._convert_record_to_cursor_record(first),
+            self._convert_record_to_cursor_record(second),
         )
 
     @staticmethod
     def _convert_record_to_cursor_record(record: Record) -> Record:
         return Record(
             record.data,
-            StreamSlice(partition={}, cursor_slice=record.associated_slice.cursor_slice) if record.associated_slice else None,
+            StreamSlice(partition={}, cursor_slice=record.associated_slice.cursor_slice)
+            if record.associated_slice
+            else None,
         )

airbyte_cdk/sources/declarative/incremental/per_partition_cursor.py

@@ -8,7 +8,9 @@ from typing import Any, Callable, Iterable, Mapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
-from airbyte_cdk.sources.streams.checkpoint.per_partition_key_serializer import PerPartitionKeySerializer
+from airbyte_cdk.sources.streams.checkpoint.per_partition_key_serializer import (
+    PerPartitionKeySerializer,
+)
 from airbyte_cdk.sources.types import Record, StreamSlice, StreamState
 
 logger = logging.getLogger("airbyte")
@@ -67,12 +69,18 @@ class PerPartitionCursor(DeclarativeCursor):
 
         cursor = self._cursor_per_partition.get(self._to_partition_key(partition.partition))
         if not cursor:
-            partition_state = self._state_to_migrate_from if self._state_to_migrate_from else self._NO_CURSOR_STATE
+            partition_state = (
+                self._state_to_migrate_from
+                if self._state_to_migrate_from
+                else self._NO_CURSOR_STATE
+            )
             cursor = self._create_cursor(partition_state)
             self._cursor_per_partition[self._to_partition_key(partition.partition)] = cursor
 
         for cursor_slice in cursor.stream_slices():
-            yield StreamSlice(partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields)
+            yield StreamSlice(
+                partition=partition, cursor_slice=cursor_slice, extra_fields=partition.extra_fields
+            )
 
     def _ensure_partition_limit(self) -> None:
         """
@@ -80,7 +88,9 @@ class PerPartitionCursor(DeclarativeCursor):
         """
         while len(self._cursor_per_partition) > self.DEFAULT_MAX_PARTITIONS_NUMBER - 1:
             self._over_limit += 1
-            oldest_partition = self._cursor_per_partition.popitem(last=False)[0]  # Remove the oldest partition
+            oldest_partition = self._cursor_per_partition.popitem(last=False)[
+                0
+            ]  # Remove the oldest partition
             logger.warning(
                 f"The maximum number of partitions has been reached. Dropping the oldest partition: {oldest_partition}. Over limit: {self._over_limit}."
             )
@@ -128,7 +138,9 @@ class PerPartitionCursor(DeclarativeCursor):
 
         else:
             for state in stream_state["states"]:
-                self._cursor_per_partition[self._to_partition_key(state["partition"])] = self._create_cursor(state["cursor"])
+                self._cursor_per_partition[self._to_partition_key(state["partition"])] = (
+                    self._create_cursor(state["cursor"])
+                )
 
             # set default state for missing partitions if it is per partition with fallback to global
             if "state" in stream_state:
@@ -214,7 +226,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_params(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_params(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -234,7 +248,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_headers(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_headers(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -254,7 +270,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_body_data(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_body_data(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -274,7 +292,9 @@ class PerPartitionCursor(DeclarativeCursor):
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition=stream_slice.partition, cursor_slice={}),
                 next_page_token=next_page_token,
-            ) | self._cursor_per_partition[self._to_partition_key(stream_slice.partition)].get_request_body_json(
+            ) | self._cursor_per_partition[
+                self._to_partition_key(stream_slice.partition)
+            ].get_request_body_json(
                 stream_state=stream_state,
                 stream_slice=StreamSlice(partition={}, cursor_slice=stream_slice.cursor_slice),
                 next_page_token=next_page_token,
@@ -283,32 +303,43 @@ class PerPartitionCursor(DeclarativeCursor):
             raise ValueError("A partition needs to be provided in order to get request body json")
 
     def should_be_synced(self, record: Record) -> bool:
-        return self._get_cursor(record).should_be_synced(self._convert_record_to_cursor_record(record))
+        return self._get_cursor(record).should_be_synced(
+            self._convert_record_to_cursor_record(record)
+        )
 
     def is_greater_than_or_equal(self, first: Record, second: Record) -> bool:
         if not first.associated_slice or not second.associated_slice:
-            raise ValueError(f"Both records should have an associated slice but got {first.associated_slice} and {second.associated_slice}")
+            raise ValueError(
+                f"Both records should have an associated slice but got {first.associated_slice} and {second.associated_slice}"
+            )
         if first.associated_slice.partition != second.associated_slice.partition:
             raise ValueError(
                 f"To compare records, partition should be the same but got {first.associated_slice.partition} and {second.associated_slice.partition}"
             )
 
         return self._get_cursor(first).is_greater_than_or_equal(
-            self._convert_record_to_cursor_record(first), self._convert_record_to_cursor_record(second)
+            self._convert_record_to_cursor_record(first),
+            self._convert_record_to_cursor_record(second),
         )
 
     @staticmethod
     def _convert_record_to_cursor_record(record: Record) -> Record:
         return Record(
             record.data,
-            StreamSlice(partition={}, cursor_slice=record.associated_slice.cursor_slice) if record.associated_slice else None,
+            StreamSlice(partition={}, cursor_slice=record.associated_slice.cursor_slice)
+            if record.associated_slice
+            else None,
         )
 
     def _get_cursor(self, record: Record) -> DeclarativeCursor:
         if not record.associated_slice:
-            raise ValueError("Invalid state as stream slices that are emitted should refer to an existing cursor")
+            raise ValueError(
+                "Invalid state as stream slices that are emitted should refer to an existing cursor"
+            )
         partition_key = self._to_partition_key(record.associated_slice.partition)
         if partition_key not in self._cursor_per_partition:
-            raise ValueError("Invalid state as stream slices that are emitted should refer to an existing cursor")
+            raise ValueError(
+                "Invalid state as stream slices that are emitted should refer to an existing cursor"
+            )
         cursor = self._cursor_per_partition[partition_key]
         return cursor

airbyte_cdk/sources/declarative/incremental/per_partition_with_global.py

@@ -5,8 +5,14 @@ from typing import Any, Iterable, Mapping, MutableMapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.incremental.datetime_based_cursor import DatetimeBasedCursor
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
-from airbyte_cdk.sources.declarative.incremental.global_substream_cursor import GlobalSubstreamCursor, iterate_with_last_flag_and_state
-from airbyte_cdk.sources.declarative.incremental.per_partition_cursor import CursorFactory, PerPartitionCursor
+from airbyte_cdk.sources.declarative.incremental.global_substream_cursor import (
+    GlobalSubstreamCursor,
+    iterate_with_last_flag_and_state,
+)
+from airbyte_cdk.sources.declarative.incremental.per_partition_cursor import (
+    CursorFactory,
+    PerPartitionCursor,
+)
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
 from airbyte_cdk.sources.types import Record, StreamSlice, StreamState
 
@@ -60,7 +66,12 @@ class PerPartitionWithGlobalCursor(DeclarativeCursor):
     Suitable for streams where the number of partitions may vary significantly, requiring dynamic switching between per-partition and global state management to ensure data consistency and efficient synchronization.
     """
 
-    def __init__(self, cursor_factory: CursorFactory, partition_router: PartitionRouter, stream_cursor: DatetimeBasedCursor):
+    def __init__(
+        self,
+        cursor_factory: CursorFactory,
+        partition_router: PartitionRouter,
+        stream_cursor: DatetimeBasedCursor,
+    ):
         self._partition_router = partition_router
         self._per_partition_cursor = PerPartitionCursor(cursor_factory, partition_router)
         self._global_cursor = GlobalSubstreamCursor(stream_cursor, partition_router)
@@ -82,7 +93,8 @@ class PerPartitionWithGlobalCursor(DeclarativeCursor):
             # Generate slices for the current cursor and handle the last slice using the flag
             self._parent_state = parent_state
             for slice, is_last_slice, _ in iterate_with_last_flag_and_state(
-                self._get_active_cursor().generate_slices_from_partition(partition=partition), lambda: None
+                self._get_active_cursor().generate_slices_from_partition(partition=partition),
+                lambda: None,
             ):
                 self._global_cursor.register_slice(is_last_slice and is_last_partition)
                 yield slice
@@ -182,7 +194,9 @@ class PerPartitionWithGlobalCursor(DeclarativeCursor):
         )
 
     def should_be_synced(self, record: Record) -> bool:
-        return self._global_cursor.should_be_synced(record) or self._per_partition_cursor.should_be_synced(record)
+        return self._global_cursor.should_be_synced(
+            record
+        ) or self._per_partition_cursor.should_be_synced(record)
 
     def is_greater_than_or_equal(self, first: Record, second: Record) -> bool:
         return self._global_cursor.is_greater_than_or_equal(first, second)

airbyte_cdk/sources/declarative/incremental/resumable_full_refresh_cursor.py

@@ -30,7 +30,9 @@ class ResumableFullRefreshCursor(DeclarativeCursor):
     def close_slice(self, stream_slice: StreamSlice, *args: Any) -> None:
         # The ResumableFullRefreshCursor doesn't support nested streams yet so receiving a partition is unexpected
         if stream_slice.partition:
-            raise ValueError(f"Stream slice {stream_slice} should not have a partition. Got {stream_slice.partition}.")
+            raise ValueError(
+                f"Stream slice {stream_slice} should not have a partition. Got {stream_slice.partition}."
+            )
         self._cursor = stream_slice.cursor_slice
 
     def should_be_synced(self, record: Record) -> bool:

airbyte_cdk/sources/declarative/interpolation/interpolated_boolean.py

@@ -8,7 +8,21 @@ from typing import Any, Final, List, Mapping
 from airbyte_cdk.sources.declarative.interpolation.jinja import JinjaInterpolation
 from airbyte_cdk.sources.types import Config
 
-FALSE_VALUES: Final[List[Any]] = ["False", "false", "{}", "[]", "()", "", "0", "0.0", {}, False, [], (), set()]
+FALSE_VALUES: Final[List[Any]] = [
+    "False",
+    "false",
+    "{}",
+    "[]",
+    "()",
+    "",
+    "0",
+    "0.0",
+    {},
+    False,
+    [],
+    (),
+    set(),
+]
 
 
 @dataclass
@@ -40,7 +54,11 @@ class InterpolatedBoolean:
             return self.condition
         else:
             evaluated = self._interpolation.eval(
-                self.condition, config, self._default, parameters=self._parameters, **additional_parameters
+                self.condition,
+                config,
+                self._default,
+                parameters=self._parameters,
+                **additional_parameters,
             )
             if evaluated in FALSE_VALUES:
                 return False