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

airbyte_cdk/sources/declarative/requesters/http_job_repository.py

@@ -12,8 +12,13 @@ from airbyte_cdk.models import FailureType, Type
 from airbyte_cdk.sources.declarative.async_job.job import AsyncJob
 from airbyte_cdk.sources.declarative.async_job.repository import AsyncJobRepository
 from airbyte_cdk.sources.declarative.async_job.status import AsyncJobStatus
-from airbyte_cdk.sources.declarative.extractors.dpath_extractor import DpathExtractor, RecordExtractor
-from airbyte_cdk.sources.declarative.extractors.response_to_file_extractor import ResponseToFileExtractor
+from airbyte_cdk.sources.declarative.extractors.dpath_extractor import (
+    DpathExtractor,
+    RecordExtractor,
+)
+from airbyte_cdk.sources.declarative.extractors.response_to_file_extractor import (
+    ResponseToFileExtractor,
+)
 from airbyte_cdk.sources.declarative.requesters.requester import Requester
 from airbyte_cdk.sources.declarative.retrievers.simple_retriever import SimpleRetriever
 from airbyte_cdk.sources.types import Record, StreamSlice
@@ -35,7 +40,9 @@ class AsyncHttpJobRepository(AsyncJobRepository):
     urls_extractor: DpathExtractor
 
     job_timeout: Optional[timedelta] = None
-    record_extractor: RecordExtractor = field(init=False, repr=False, default_factory=lambda: ResponseToFileExtractor())
+    record_extractor: RecordExtractor = field(
+        init=False, repr=False, default_factory=lambda: ResponseToFileExtractor()
+    )
 
     def __post_init__(self) -> None:
         self._create_job_response_by_id: Dict[str, Response] = {}
@@ -55,7 +62,9 @@ class AsyncHttpJobRepository(AsyncJobRepository):
             AirbyteTracedException: If the polling request returns an empty response.
         """
 
-        polling_response: Optional[requests.Response] = self.polling_requester.send_request(stream_slice=stream_slice)
+        polling_response: Optional[requests.Response] = self.polling_requester.send_request(
+            stream_slice=stream_slice
+        )
         if polling_response is None:
             raise AirbyteTracedException(
                 internal_message="Polling Requester received an empty Response.",
@@ -100,7 +109,9 @@ class AsyncHttpJobRepository(AsyncJobRepository):
             AirbyteTracedException: If no response is received from the creation requester.
         """
 
-        response: Optional[requests.Response] = self.creation_requester.send_request(stream_slice=stream_slice)
+        response: Optional[requests.Response] = self.creation_requester.send_request(
+            stream_slice=stream_slice
+        )
         if not response:
             raise AirbyteTracedException(
                 internal_message="Always expect a response or an exception from creation_requester",
@@ -146,9 +157,17 @@ class AsyncHttpJobRepository(AsyncJobRepository):
             job_status: AsyncJobStatus = self._get_validated_job_status(polling_response)
 
             if job_status != job.status():
-                lazy_log(LOGGER, logging.DEBUG, lambda: f"Status of job {job.api_job_id()} changed from {job.status()} to {job_status}")
+                lazy_log(
+                    LOGGER,
+                    logging.DEBUG,
+                    lambda: f"Status of job {job.api_job_id()} changed from {job.status()} to {job_status}",
+                )
             else:
-                lazy_log(LOGGER, logging.DEBUG, lambda: f"Status of job {job.api_job_id()} is still {job.status()}")
+                lazy_log(
+                    LOGGER,
+                    logging.DEBUG,
+                    lambda: f"Status of job {job.api_job_id()} is still {job.status()}",
+                )
 
             job.update_status(job_status)
             if job_status == AsyncJobStatus.COMPLETED:
@@ -166,7 +185,9 @@ class AsyncHttpJobRepository(AsyncJobRepository):
 
         """
 
-        for url in self.urls_extractor.extract_records(self._polling_job_response_by_id[job.api_job_id()]):
+        for url in self.urls_extractor.extract_records(
+            self._polling_job_response_by_id[job.api_job_id()]
+        ):
             stream_slice: StreamSlice = StreamSlice(partition={"url": url}, cursor_slice={})
             for message in self.download_retriever.read_records({}, stream_slice):
                 if isinstance(message, Record):

airbyte_cdk/sources/declarative/requesters/http_requester.py

@@ -9,7 +9,10 @@ from typing import Any, Callable, Mapping, MutableMapping, Optional, Union
 from urllib.parse import urljoin
 
 import requests
-from airbyte_cdk.sources.declarative.auth.declarative_authenticator import DeclarativeAuthenticator, NoAuth
+from airbyte_cdk.sources.declarative.auth.declarative_authenticator import (
+    DeclarativeAuthenticator,
+    NoAuth,
+)
 from airbyte_cdk.sources.declarative.decoders import Decoder
 from airbyte_cdk.sources.declarative.decoders.json_decoder import JsonDecoder
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
@@ -62,13 +65,19 @@ class HttpRequester(Requester):
         self._url_base = InterpolatedString.create(self.url_base, parameters=parameters)
         self._path = InterpolatedString.create(self.path, parameters=parameters)
         if self.request_options_provider is None:
-            self._request_options_provider = InterpolatedRequestOptionsProvider(config=self.config, parameters=parameters)
+            self._request_options_provider = InterpolatedRequestOptionsProvider(
+                config=self.config, parameters=parameters
+            )
         elif isinstance(self.request_options_provider, dict):
-            self._request_options_provider = InterpolatedRequestOptionsProvider(config=self.config, **self.request_options_provider)
+            self._request_options_provider = InterpolatedRequestOptionsProvider(
+                config=self.config, **self.request_options_provider
+            )
         else:
             self._request_options_provider = self.request_options_provider
         self._authenticator = self.authenticator or NoAuth(parameters=parameters)
-        self._http_method = HttpMethod[self.http_method] if isinstance(self.http_method, str) else self.http_method
+        self._http_method = (
+            HttpMethod[self.http_method] if isinstance(self.http_method, str) else self.http_method
+        )
         self.error_handler = self.error_handler
         self._parameters = parameters
 
@@ -103,9 +112,17 @@ class HttpRequester(Requester):
         return os.path.join(self._url_base.eval(self.config), "")
 
     def get_path(
-        self, *, stream_state: Optional[StreamState], stream_slice: Optional[StreamSlice], next_page_token: Optional[Mapping[str, Any]]
+        self,
+        *,
+        stream_state: Optional[StreamState],
+        stream_slice: Optional[StreamSlice],
+        next_page_token: Optional[Mapping[str, Any]],
     ) -> str:
-        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,
+        }
         path = str(self._path.eval(self.config, **kwargs))
         return path.lstrip("/")
 
@@ -144,7 +161,9 @@ class HttpRequester(Requester):
     ) -> Union[Mapping[str, Any], str]:
         return (
             self._request_options_provider.get_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,
             )
             or {}
         )
@@ -181,7 +200,11 @@ class HttpRequester(Requester):
         """
         return combine_mappings(
             [
-                requester_method(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
+                requester_method(
+                    stream_state=stream_state,
+                    stream_slice=stream_slice,
+                    next_page_token=next_page_token,
+                ),
                 auth_options_method(),
                 extra_options,
             ]
@@ -223,14 +246,21 @@ class HttpRequester(Requester):
         E.g: you might want to define query parameters for paging if next_page_token is not None.
         """
         options = self._get_request_options(
-            stream_state, stream_slice, next_page_token, self.get_request_params, self.get_authenticator().get_request_params, extra_params
+            stream_state,
+            stream_slice,
+            next_page_token,
+            self.get_request_params,
+            self.get_authenticator().get_request_params,
+            extra_params,
         )
         if isinstance(options, str):
             raise ValueError("Request params cannot be a string")
 
         for k, v in options.items():
             if isinstance(v, (dict,)):
-                raise ValueError(f"Invalid value for `{k}` parameter. The values of request params cannot be an object.")
+                raise ValueError(
+                    f"Invalid value for `{k}` parameter. The values of request params cannot be an object."
+                )
 
         return options
 
@@ -301,18 +331,30 @@ class HttpRequester(Requester):
         request_body_json: Optional[Mapping[str, Any]] = None,
         log_formatter: Optional[Callable[[requests.Response], Any]] = None,
     ) -> Optional[requests.Response]:
-
         request, response = self._http_client.send_request(
             http_method=self.get_method().value,
             url=self._join_url(
                 self.get_url_base(),
-                path or self.get_path(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token),
+                path
+                or self.get_path(
+                    stream_state=stream_state,
+                    stream_slice=stream_slice,
+                    next_page_token=next_page_token,
+                ),
             ),
             request_kwargs={"stream": self.stream_response},
-            headers=self._request_headers(stream_state, stream_slice, next_page_token, request_headers),
-            params=self._request_params(stream_state, stream_slice, next_page_token, request_params),
-            json=self._request_body_json(stream_state, stream_slice, next_page_token, request_body_json),
-            data=self._request_body_data(stream_state, stream_slice, next_page_token, request_body_data),
+            headers=self._request_headers(
+                stream_state, stream_slice, next_page_token, request_headers
+            ),
+            params=self._request_params(
+                stream_state, stream_slice, next_page_token, request_params
+            ),
+            json=self._request_body_json(
+                stream_state, stream_slice, next_page_token, request_body_json
+            ),
+            data=self._request_body_data(
+                stream_state, stream_slice, next_page_token, request_body_data
+            ),
             dedupe_query_params=True,
             log_formatter=log_formatter,
             exit_on_rate_limit=self._exit_on_rate_limit,

airbyte_cdk/sources/declarative/requesters/paginators/default_paginator.py

@@ -6,11 +6,20 @@ from dataclasses import InitVar, dataclass, field
 from typing import Any, Mapping, MutableMapping, Optional, Union
 
 import requests
-from airbyte_cdk.sources.declarative.decoders import Decoder, JsonDecoder, PaginationDecoderDecorator
+from airbyte_cdk.sources.declarative.decoders import (
+    Decoder,
+    JsonDecoder,
+    PaginationDecoderDecorator,
+)
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.declarative.requesters.paginators.paginator import Paginator
-from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import PaginationStrategy
-from airbyte_cdk.sources.declarative.requesters.request_option import RequestOption, RequestOptionType
+from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import (
+    PaginationStrategy,
+)
+from airbyte_cdk.sources.declarative.requesters.request_option import (
+    RequestOption,
+    RequestOptionType,
+)
 from airbyte_cdk.sources.declarative.requesters.request_path import RequestPath
 from airbyte_cdk.sources.types import Config, Record, StreamSlice, StreamState
 
@@ -89,13 +98,17 @@ class DefaultPaginator(Paginator):
     config: Config
     url_base: Union[InterpolatedString, str]
     parameters: InitVar[Mapping[str, Any]]
-    decoder: Decoder = field(default_factory=lambda: PaginationDecoderDecorator(decoder=JsonDecoder(parameters={})))
+    decoder: Decoder = field(
+        default_factory=lambda: PaginationDecoderDecorator(decoder=JsonDecoder(parameters={}))
+    )
     page_size_option: Optional[RequestOption] = None
     page_token_option: Optional[Union[RequestPath, RequestOption]] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         if self.page_size_option and not self.pagination_strategy.get_page_size():
-            raise ValueError("page_size_option cannot be set if the pagination strategy does not have a page_size")
+            raise ValueError(
+                "page_size_option cannot be set if the pagination strategy does not have a page_size"
+            )
         if isinstance(self.url_base, str):
             self.url_base = InterpolatedString(string=self.url_base, parameters=parameters)
         self._token: Optional[Any] = self.pagination_strategy.initial_token
@@ -103,14 +116,20 @@ class DefaultPaginator(Paginator):
     def next_page_token(
         self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
     ) -> Optional[Mapping[str, Any]]:
-        self._token = self.pagination_strategy.next_page_token(response, last_page_size, last_record)
+        self._token = self.pagination_strategy.next_page_token(
+            response, last_page_size, last_record
+        )
         if self._token:
             return {"next_page_token": self._token}
         else:
             return None
 
     def path(self) -> Optional[str]:
-        if self._token and self.page_token_option and isinstance(self.page_token_option, RequestPath):
+        if (
+            self._token
+            and self.page_token_option
+            and isinstance(self.page_token_option, RequestPath)
+        ):
             # Replace url base to only return the path
             return str(self._token).replace(self.url_base.eval(self.config), "")  # type: ignore # url_base is casted to a InterpolatedString in __post_init__
         else:
@@ -169,8 +188,14 @@ class DefaultPaginator(Paginator):
             and self.page_token_option.inject_into == option_type
         ):
             options[self.page_token_option.field_name.eval(config=self.config)] = self._token  # type: ignore # field_name is always cast to an interpolated string
-        if self.page_size_option and self.pagination_strategy.get_page_size() and self.page_size_option.inject_into == option_type:
-            options[self.page_size_option.field_name.eval(config=self.config)] = self.pagination_strategy.get_page_size()  # type: ignore # field_name is always cast to an interpolated string
+        if (
+            self.page_size_option
+            and self.pagination_strategy.get_page_size()
+            and self.page_size_option.inject_into == option_type
+        ):
+            options[self.page_size_option.field_name.eval(config=self.config)] = (
+                self.pagination_strategy.get_page_size()
+            )  # type: ignore # field_name is always cast to an interpolated string
         return options
 
 
@@ -184,7 +209,9 @@ class PaginatorTestReadDecorator(Paginator):
 
     def __init__(self, decorated: Paginator, maximum_number_of_pages: int = 5) -> None:
         if maximum_number_of_pages and maximum_number_of_pages < 1:
-            raise ValueError(f"The maximum number of pages on a test read needs to be strictly positive. Got {maximum_number_of_pages}")
+            raise ValueError(
+                f"The maximum number of pages on a test read needs to be strictly positive. Got {maximum_number_of_pages}"
+            )
         self._maximum_number_of_pages = maximum_number_of_pages
         self._decorated = decorated
         self._page_count = self._PAGE_COUNT_BEFORE_FIRST_NEXT_CALL
@@ -208,7 +235,9 @@ class PaginatorTestReadDecorator(Paginator):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, Any]:
-        return self._decorated.get_request_params(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+        return self._decorated.get_request_params(
+            stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+        )
 
     def get_request_headers(
         self,
@@ -217,7 +246,9 @@ class PaginatorTestReadDecorator(Paginator):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, str]:
-        return self._decorated.get_request_headers(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+        return self._decorated.get_request_headers(
+            stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+        )
 
     def get_request_body_data(
         self,
@@ -226,7 +257,9 @@ class PaginatorTestReadDecorator(Paginator):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Union[Mapping[str, Any], str]:
-        return self._decorated.get_request_body_data(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+        return self._decorated.get_request_body_data(
+            stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+        )
 
     def get_request_body_json(
         self,
@@ -235,7 +268,9 @@ class PaginatorTestReadDecorator(Paginator):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, Any]:
-        return self._decorated.get_request_body_json(stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token)
+        return self._decorated.get_request_body_json(
+            stream_state=stream_state, stream_slice=stream_slice, next_page_token=next_page_token
+        )
 
     def reset(self, reset_value: Optional[Any] = None) -> None:
         self._decorated.reset()

airbyte_cdk/sources/declarative/requesters/paginators/no_pagination.py

@@ -57,7 +57,9 @@ class NoPagination(Paginator):
     ) -> Mapping[str, Any]:
         return {}
 
-    def next_page_token(self, response: requests.Response, last_page_size: int, last_record: Optional[Record]) -> Mapping[str, Any]:
+    def next_page_token(
+        self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
+    ) -> Mapping[str, Any]:
         return {}
 
     def reset(self, reset_value: Optional[Any] = None) -> None:

airbyte_cdk/sources/declarative/requesters/paginators/paginator.py

@@ -7,7 +7,9 @@ from dataclasses import dataclass
 from typing import Any, Mapping, Optional
 
 import requests
-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 Record
 
 

airbyte_cdk/sources/declarative/requesters/paginators/strategies/cursor_pagination_strategy.py

@@ -6,10 +6,16 @@ from dataclasses import InitVar, dataclass, field
 from typing import Any, Dict, Mapping, Optional, Union
 
 import requests
-from airbyte_cdk.sources.declarative.decoders import Decoder, JsonDecoder, PaginationDecoderDecorator
+from airbyte_cdk.sources.declarative.decoders import (
+    Decoder,
+    JsonDecoder,
+    PaginationDecoderDecorator,
+)
 from airbyte_cdk.sources.declarative.interpolation.interpolated_boolean import InterpolatedBoolean
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import PaginationStrategy
+from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import (
+    PaginationStrategy,
+)
 from airbyte_cdk.sources.types import Config, Record
 
 
@@ -31,7 +37,9 @@ class CursorPaginationStrategy(PaginationStrategy):
     parameters: InitVar[Mapping[str, Any]]
     page_size: Optional[int] = None
     stop_condition: Optional[Union[InterpolatedBoolean, str]] = None
-    decoder: Decoder = field(default_factory=lambda: PaginationDecoderDecorator(decoder=JsonDecoder(parameters={})))
+    decoder: Decoder = field(
+        default_factory=lambda: PaginationDecoderDecorator(decoder=JsonDecoder(parameters={}))
+    )
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._initial_cursor = None
@@ -40,7 +48,9 @@ class CursorPaginationStrategy(PaginationStrategy):
         else:
             self._cursor_value = self.cursor_value
         if isinstance(self.stop_condition, str):
-            self._stop_condition: Optional[InterpolatedBoolean] = InterpolatedBoolean(condition=self.stop_condition, parameters=parameters)
+            self._stop_condition: Optional[InterpolatedBoolean] = InterpolatedBoolean(
+                condition=self.stop_condition, parameters=parameters
+            )
         else:
             self._stop_condition = self.stop_condition
 
@@ -48,7 +58,9 @@ class CursorPaginationStrategy(PaginationStrategy):
     def initial_token(self) -> Optional[Any]:
         return self._initial_cursor
 
-    def next_page_token(self, response: requests.Response, last_page_size: int, last_record: Optional[Record]) -> Optional[Any]:
+    def next_page_token(
+        self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
+    ) -> Optional[Any]:
         decoded_response = next(self.decoder.decode(response))
 
         # The default way that link is presented in requests.Response is a string of various links (last, next, etc). This

airbyte_cdk/sources/declarative/requesters/paginators/strategies/offset_increment.py

@@ -6,9 +6,15 @@ from dataclasses import InitVar, dataclass, field
 from typing import Any, Mapping, Optional, Union
 
 import requests
-from airbyte_cdk.sources.declarative.decoders import Decoder, JsonDecoder, PaginationDecoderDecorator
+from airbyte_cdk.sources.declarative.decoders import (
+    Decoder,
+    JsonDecoder,
+    PaginationDecoderDecorator,
+)
 from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
-from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import PaginationStrategy
+from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import (
+    PaginationStrategy,
+)
 from airbyte_cdk.sources.types import Config, Record
 
 
@@ -39,14 +45,18 @@ class OffsetIncrement(PaginationStrategy):
     config: Config
     page_size: Optional[Union[str, int]]
     parameters: InitVar[Mapping[str, Any]]
-    decoder: Decoder = field(default_factory=lambda: PaginationDecoderDecorator(decoder=JsonDecoder(parameters={})))
+    decoder: Decoder = field(
+        default_factory=lambda: PaginationDecoderDecorator(decoder=JsonDecoder(parameters={}))
+    )
     inject_on_first_request: bool = False
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._offset = 0
         page_size = str(self.page_size) if isinstance(self.page_size, int) else self.page_size
         if page_size:
-            self._page_size: Optional[InterpolatedString] = InterpolatedString(page_size, parameters=parameters)
+            self._page_size: Optional[InterpolatedString] = InterpolatedString(
+                page_size, parameters=parameters
+            )
         else:
             self._page_size = None
 
@@ -56,11 +66,16 @@ class OffsetIncrement(PaginationStrategy):
             return self._offset
         return None
 
-    def next_page_token(self, response: requests.Response, last_page_size: int, last_record: Optional[Record]) -> Optional[Any]:
+    def next_page_token(
+        self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
+    ) -> Optional[Any]:
         decoded_response = next(self.decoder.decode(response))
 
         # Stop paginating when there are fewer records than the page size or the current page has no records
-        if (self._page_size and last_page_size < self._page_size.eval(self.config, response=decoded_response)) or last_page_size == 0:
+        if (
+            self._page_size
+            and last_page_size < self._page_size.eval(self.config, response=decoded_response)
+        ) or last_page_size == 0:
             return None
         else:
             self._offset += last_page_size
@@ -68,7 +83,9 @@ class OffsetIncrement(PaginationStrategy):
 
     def reset(self, reset_value: Optional[Any] = 0) -> None:
         if not isinstance(reset_value, int):
-            raise ValueError(f"Reset value {reset_value} for OffsetIncrement pagination strategy was not an integer")
+            raise ValueError(
+                f"Reset value {reset_value} for OffsetIncrement pagination strategy was not an integer"
+            )
         else:
             self._offset = reset_value
 

airbyte_cdk/sources/declarative/requesters/paginators/strategies/page_increment.py

@@ -7,7 +7,9 @@ from typing import Any, Mapping, Optional, Union
 
 import requests
 from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
-from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import PaginationStrategy
+from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import (
+    PaginationStrategy,
+)
 from airbyte_cdk.sources.types import Config, Record
 
 
@@ -43,7 +45,9 @@ class PageIncrement(PaginationStrategy):
             return self._page
         return None
 
-    def next_page_token(self, response: requests.Response, last_page_size: int, last_record: Optional[Record]) -> Optional[Any]:
+    def next_page_token(
+        self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
+    ) -> Optional[Any]:
         # Stop paginating when there are fewer records than the page size or the current page has no records
         if (self._page_size and last_page_size < self._page_size) or last_page_size == 0:
             return None
@@ -55,7 +59,9 @@ class PageIncrement(PaginationStrategy):
         if reset_value is None:
             self._page = self.start_from_page
         elif not isinstance(reset_value, int):
-            raise ValueError(f"Reset value {reset_value} for PageIncrement pagination strategy was not an integer")
+            raise ValueError(
+                f"Reset value {reset_value} for PageIncrement pagination strategy was not an integer"
+            )
         else:
             self._page = reset_value
 

airbyte_cdk/sources/declarative/requesters/paginators/strategies/pagination_strategy.py

@@ -24,7 +24,9 @@ class PaginationStrategy:
         """
 
     @abstractmethod
-    def next_page_token(self, response: requests.Response, last_page_size: int, last_record: Optional[Record]) -> Optional[Any]:
+    def next_page_token(
+        self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
+    ) -> Optional[Any]:
         """
         :param response: response to process
         :param last_page_size: the number of records read from the response

airbyte_cdk/sources/declarative/requesters/paginators/strategies/stop_condition.py

@@ -7,7 +7,9 @@ from typing import Any, Optional
 
 import requests
 from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
-from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import PaginationStrategy
+from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import (
+    PaginationStrategy,
+)
 from airbyte_cdk.sources.types import Record
 
 
@@ -35,7 +37,9 @@ class StopConditionPaginationStrategyDecorator(PaginationStrategy):
         self._delegate = _delegate
         self._stop_condition = stop_condition
 
-    def next_page_token(self, response: requests.Response, last_page_size: int, last_record: Optional[Record]) -> Optional[Any]:
+    def next_page_token(
+        self, response: requests.Response, last_page_size: int, last_record: Optional[Record]
+    ) -> Optional[Any]:
         # We evaluate in reverse order because the assumption is that most of the APIs using data feed structure will return records in
         # descending order. In terms of performance/memory, we return the records lazily
         if last_record and self._stop_condition.is_met(last_record):

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

@@ -6,8 +6,13 @@ from dataclasses import InitVar, dataclass
 from typing import Any, Mapping, MutableMapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.declarative.requesters.request_option import RequestOption, RequestOptionType
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
+from airbyte_cdk.sources.declarative.requesters.request_option import (
+    RequestOption,
+    RequestOptionType,
+)
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
 
@@ -26,8 +31,12 @@ class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
     partition_field_end: Optional[str] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> 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._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
+        )
 
     def get_request_params(
         self,
@@ -65,7 +74,9 @@ class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
     ) -> Mapping[str, Any]:
         return self._get_request_options(RequestOptionType.body_json, stream_slice)
 
-    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
@@ -74,5 +85,7 @@ class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
                 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

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

@@ -5,7 +5,9 @@
 from dataclasses import InitVar, dataclass
 from typing import Any, Mapping, Optional, Union
 
-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