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

airbyte_cdk/sources/connector_state_manager.py

@@ -6,7 +6,14 @@ import copy
 from dataclasses import dataclass
 from typing import Any, List, Mapping, MutableMapping, Optional, Tuple, Union
 
-from airbyte_cdk.models import AirbyteMessage, AirbyteStateBlob, AirbyteStateMessage, AirbyteStateType, AirbyteStreamState, StreamDescriptor
+from airbyte_cdk.models import (
+    AirbyteMessage,
+    AirbyteStateBlob,
+    AirbyteStateMessage,
+    AirbyteStateType,
+    AirbyteStreamState,
+    StreamDescriptor,
+)
 from airbyte_cdk.models import Type as MessageType
 
 
@@ -42,19 +49,25 @@ class ConnectorStateManager:
             )
         self.per_stream_states = per_stream_states
 
-    def get_stream_state(self, stream_name: str, namespace: Optional[str]) -> MutableMapping[str, Any]:
+    def get_stream_state(
+        self, stream_name: str, namespace: Optional[str]
+    ) -> MutableMapping[str, Any]:
         """
         Retrieves the state of a given stream based on its descriptor (name + namespace).
         :param stream_name: Name of the stream being fetched
         :param namespace: Namespace of the stream being fetched
         :return: The per-stream state for a stream
         """
-        stream_state: AirbyteStateBlob | None = self.per_stream_states.get(HashableStreamDescriptor(name=stream_name, namespace=namespace))
+        stream_state: AirbyteStateBlob | None = self.per_stream_states.get(
+            HashableStreamDescriptor(name=stream_name, namespace=namespace)
+        )
         if stream_state:
             return copy.deepcopy({k: v for k, v in stream_state.__dict__.items()})
         return {}
 
-    def update_state_for_stream(self, stream_name: str, namespace: Optional[str], value: Mapping[str, Any]) -> None:
+    def update_state_for_stream(
+        self, stream_name: str, namespace: Optional[str], value: Mapping[str, Any]
+    ) -> None:
         """
         Overwrites the state blob of a specific stream based on the provided stream name and optional namespace
         :param stream_name: The name of the stream whose state is being updated
@@ -79,7 +92,8 @@ class ConnectorStateManager:
             state=AirbyteStateMessage(
                 type=AirbyteStateType.STREAM,
                 stream=AirbyteStreamState(
-                    stream_descriptor=StreamDescriptor(name=stream_name, namespace=namespace), stream_state=stream_state
+                    stream_descriptor=StreamDescriptor(name=stream_name, namespace=namespace),
+                    stream_state=stream_state,
                 ),
             ),
         )
@@ -88,7 +102,10 @@ class ConnectorStateManager:
     def _extract_from_state_message(
         cls,
         state: Optional[List[AirbyteStateMessage]],
-    ) -> Tuple[Optional[AirbyteStateBlob], MutableMapping[HashableStreamDescriptor, Optional[AirbyteStateBlob]]]:
+    ) -> Tuple[
+        Optional[AirbyteStateBlob],
+        MutableMapping[HashableStreamDescriptor, Optional[AirbyteStateBlob]],
+    ]:
         """
         Takes an incoming list of state messages or a global state message and extracts state attributes according to
         type which can then be assigned to the new state manager being instantiated
@@ -105,7 +122,8 @@ class ConnectorStateManager:
             shared_state = copy.deepcopy(global_state.shared_state, {})  # type: ignore[union-attr] # global_state has shared_state
             streams = {
                 HashableStreamDescriptor(
-                    name=per_stream_state.stream_descriptor.name, namespace=per_stream_state.stream_descriptor.namespace
+                    name=per_stream_state.stream_descriptor.name,
+                    namespace=per_stream_state.stream_descriptor.namespace,
                 ): per_stream_state.stream_state
                 for per_stream_state in global_state.stream_states  # type: ignore[union-attr] # global_state has shared_state
             }
@@ -113,10 +131,12 @@ class ConnectorStateManager:
         else:
             streams = {
                 HashableStreamDescriptor(
-                    name=per_stream_state.stream.stream_descriptor.name, namespace=per_stream_state.stream.stream_descriptor.namespace  # type: ignore[union-attr] # stream has stream_descriptor
+                    name=per_stream_state.stream.stream_descriptor.name,
+                    namespace=per_stream_state.stream.stream_descriptor.namespace,  # type: ignore[union-attr] # stream has stream_descriptor
                 ): per_stream_state.stream.stream_state  # type: ignore[union-attr] # stream has stream_state
                 for per_stream_state in state
-                if per_stream_state.type == AirbyteStateType.STREAM and hasattr(per_stream_state, "stream")  # type: ignore # state is always a list of AirbyteStateMessage if is_per_stream is True
+                if per_stream_state.type == AirbyteStateType.STREAM
+                and hasattr(per_stream_state, "stream")  # type: ignore # state is always a list of AirbyteStateMessage if is_per_stream is True
             }
             return None, streams
 
@@ -130,5 +150,7 @@ class ConnectorStateManager:
         )
 
     @staticmethod
-    def _is_per_stream_state(state: Union[List[AirbyteStateMessage], MutableMapping[str, Any]]) -> bool:
+    def _is_per_stream_state(
+        state: Union[List[AirbyteStateMessage], MutableMapping[str, Any]],
+    ) -> bool:
         return isinstance(state, List)

airbyte_cdk/sources/declarative/async_job/job.py

@@ -18,7 +18,9 @@ class AsyncJob:
     it and call `ApiJob.update_status`, `ApiJob.status` will not reflect the actual API side status.
     """
 
-    def __init__(self, api_job_id: str, job_parameters: StreamSlice, timeout: Optional[timedelta] = None) -> None:
+    def __init__(
+        self, api_job_id: str, job_parameters: StreamSlice, timeout: Optional[timedelta] = None
+    ) -> None:
         self._api_job_id = api_job_id
         self._job_parameters = job_parameters
         self._status = AsyncJobStatus.RUNNING

airbyte_cdk/sources/declarative/async_job/job_orchestrator.py

@@ -6,13 +6,28 @@ import time
 import traceback
 import uuid
 from datetime import timedelta
-from typing import Any, Generator, Generic, Iterable, List, Mapping, Optional, Set, Tuple, Type, TypeVar
+from typing import (
+    Any,
+    Generator,
+    Generic,
+    Iterable,
+    List,
+    Mapping,
+    Optional,
+    Set,
+    Tuple,
+    Type,
+    TypeVar,
+)
 
 from airbyte_cdk import StreamSlice
 from airbyte_cdk.logger import lazy_log
 from airbyte_cdk.models import FailureType
 from airbyte_cdk.sources.declarative.async_job.job import AsyncJob
-from airbyte_cdk.sources.declarative.async_job.job_tracker import ConcurrentJobLimitReached, JobTracker
+from airbyte_cdk.sources.declarative.async_job.job_tracker import (
+    ConcurrentJobLimitReached,
+    JobTracker,
+)
 from airbyte_cdk.sources.declarative.async_job.repository import AsyncJobRepository
 from airbyte_cdk.sources.declarative.async_job.status import AsyncJobStatus
 from airbyte_cdk.sources.message import MessageRepository
@@ -36,7 +51,12 @@ class AsyncPartition:
         self._stream_slice = stream_slice
 
     def has_reached_max_attempt(self) -> bool:
-        return any(map(lambda attempt_count: attempt_count >= self._MAX_NUMBER_OF_ATTEMPTS, self._attempts_per_job.values()))
+        return any(
+            map(
+                lambda attempt_count: attempt_count >= self._MAX_NUMBER_OF_ATTEMPTS,
+                self._attempts_per_job.values(),
+            )
+        )
 
     def replace_job(self, job_to_replace: AsyncJob, new_jobs: List[AsyncJob]) -> None:
         current_attempt_count = self._attempts_per_job.pop(job_to_replace, None)
@@ -119,7 +139,12 @@ class LookaheadIterator(Generic[T]):
 
 class AsyncJobOrchestrator:
     _WAIT_TIME_BETWEEN_STATUS_UPDATE_IN_SECONDS = 5
-    _KNOWN_JOB_STATUSES = {AsyncJobStatus.COMPLETED, AsyncJobStatus.FAILED, AsyncJobStatus.RUNNING, AsyncJobStatus.TIMED_OUT}
+    _KNOWN_JOB_STATUSES = {
+        AsyncJobStatus.COMPLETED,
+        AsyncJobStatus.FAILED,
+        AsyncJobStatus.RUNNING,
+        AsyncJobStatus.TIMED_OUT,
+    }
     _RUNNING_ON_API_SIDE_STATUS = {AsyncJobStatus.RUNNING, AsyncJobStatus.TIMED_OUT}
 
     def __init__(
@@ -176,7 +201,11 @@ class AsyncJobOrchestrator:
             for partition in self._running_partitions:
                 self._replace_failed_jobs(partition)
 
-            if self._has_bulk_parent and self._running_partitions and self._slice_iterator.has_next():
+            if (
+                self._has_bulk_parent
+                and self._running_partitions
+                and self._slice_iterator.has_next()
+            ):
                 LOGGER.debug(
                     "This AsyncJobOrchestrator is operating as a child of a bulk stream hence we limit the number of concurrent jobs on the child until there are no more parent slices to avoid the child taking all the API job budget"
                 )
@@ -192,7 +221,9 @@ class AsyncJobOrchestrator:
             if at_least_one_slice_consumed_from_slice_iterator_during_current_iteration:
                 # this means a slice has been consumed but the job couldn't be create therefore we need to put it back at the beginning of the _slice_iterator
                 self._slice_iterator.add_at_the_beginning(_slice)  # type: ignore  # we know it's not None here because `ConcurrentJobLimitReached` happens during the for loop
-            LOGGER.debug("Waiting before creating more jobs as the limit of concurrent jobs has been reached. Will try again later...")
+            LOGGER.debug(
+                "Waiting before creating more jobs as the limit of concurrent jobs has been reached. Will try again later..."
+            )
 
     def _start_job(self, _slice: StreamSlice, previous_job_id: Optional[str] = None) -> AsyncJob:
         if previous_job_id:
@@ -212,7 +243,9 @@ class AsyncJobOrchestrator:
                 raise exception
             return self._keep_api_budget_with_failed_job(_slice, exception, id_to_replace)
 
-    def _keep_api_budget_with_failed_job(self, _slice: StreamSlice, exception: Exception, intent: str) -> AsyncJob:
+    def _keep_api_budget_with_failed_job(
+        self, _slice: StreamSlice, exception: Exception, intent: str
+    ) -> AsyncJob:
         """
         We have a mechanism to retry job. It is used when a job status is FAILED or TIMED_OUT. The easiest way to retry is to have this job
         as created in a failed state and leverage the retry for failed/timed out jobs. This way, we don't have to have another process for
@@ -221,7 +254,11 @@ class AsyncJobOrchestrator:
         LOGGER.warning(
             f"Could not start job for slice {_slice}. Job will be flagged as failed and retried if max number of attempts not reached: {exception}"
         )
-        traced_exception = exception if isinstance(exception, AirbyteTracedException) else AirbyteTracedException.from_exception(exception)
+        traced_exception = (
+            exception
+            if isinstance(exception, AirbyteTracedException)
+            else AirbyteTracedException.from_exception(exception)
+        )
         # Even though we're not sure this will break the stream, we will emit here for simplicity's sake. If we wanted to be more accurate,
         # we would keep the exceptions in-memory until we know that we have reached the max attempt.
         self._message_repository.emit_message(traced_exception.as_airbyte_message())
@@ -241,7 +278,12 @@ class AsyncJobOrchestrator:
         Returns:
             Set[AsyncJob]: A set of AsyncJob objects that are currently running.
         """
-        return {job for partition in self._running_partitions for job in partition.jobs if job.status() == AsyncJobStatus.RUNNING}
+        return {
+            job
+            for partition in self._running_partitions
+            for job in partition.jobs
+            if job.status() == AsyncJobStatus.RUNNING
+        }
 
     def _update_jobs_status(self) -> None:
         """
@@ -283,14 +325,18 @@ class AsyncJobOrchestrator:
             partition (AsyncPartition): The completed partition to process.
         """
         job_ids = list(map(lambda job: job.api_job_id(), {job for job in partition.jobs}))
-        LOGGER.info(f"The following jobs for stream slice {partition.stream_slice} have been completed: {job_ids}.")
+        LOGGER.info(
+            f"The following jobs for stream slice {partition.stream_slice} have been completed: {job_ids}."
+        )
 
         # It is important to remove the jobs from the job tracker before yielding the partition as the caller might try to schedule jobs
         # but won't be able to as all jobs slots are taken even though job is done.
         for job in partition.jobs:
             self._job_tracker.remove_job(job.api_job_id())
 
-    def _process_running_partitions_and_yield_completed_ones(self) -> Generator[AsyncPartition, Any, None]:
+    def _process_running_partitions_and_yield_completed_ones(
+        self,
+    ) -> Generator[AsyncPartition, Any, None]:
         """
         Process the running partitions.
 
@@ -392,7 +438,9 @@ class AsyncJobOrchestrator:
                 self._wait_on_status_update()
             except Exception as exception:
                 if self._is_breaking_exception(exception):
-                    LOGGER.warning(f"Caught exception that stops the processing of the jobs: {exception}")
+                    LOGGER.warning(
+                        f"Caught exception that stops the processing of the jobs: {exception}"
+                    )
                     self._abort_all_running_jobs()
                     raise exception
 
@@ -406,7 +454,12 @@ class AsyncJobOrchestrator:
             # call of `create_and_get_completed_partitions` knows that there was an issue with some partitions and the sync is incomplete.
             raise AirbyteTracedException(
                 message="",
-                internal_message="\n".join([filter_secrets(exception.__repr__()) for exception in self._non_breaking_exceptions]),
+                internal_message="\n".join(
+                    [
+                        filter_secrets(exception.__repr__())
+                        for exception in self._non_breaking_exceptions
+                    ]
+                ),
                 failure_type=FailureType.config_error,
             )
 
@@ -425,7 +478,8 @@ class AsyncJobOrchestrator:
 
     def _is_breaking_exception(self, exception: Exception) -> bool:
         return isinstance(exception, self._exceptions_to_break_on) or (
-            isinstance(exception, AirbyteTracedException) and exception.failure_type == FailureType.config_error
+            isinstance(exception, AirbyteTracedException)
+            and exception.failure_type == FailureType.config_error
         )
 
     def fetch_records(self, partition: AsyncPartition) -> Iterable[Mapping[str, Any]]:

airbyte_cdk/sources/declarative/async_job/job_tracker.py

@@ -21,25 +21,39 @@ class JobTracker:
         self._lock = threading.Lock()
 
     def try_to_get_intent(self) -> str:
-        lazy_log(LOGGER, logging.DEBUG, lambda: f"JobTracker - Trying to acquire lock by thread {threading.get_native_id()}...")
+        lazy_log(
+            LOGGER,
+            logging.DEBUG,
+            lambda: f"JobTracker - Trying to acquire lock by thread {threading.get_native_id()}...",
+        )
         with self._lock:
             if self._has_reached_limit():
-                raise ConcurrentJobLimitReached("Can't allocate more jobs right now: limit already reached")
+                raise ConcurrentJobLimitReached(
+                    "Can't allocate more jobs right now: limit already reached"
+                )
             intent = f"intent_{str(uuid.uuid4())}"
-            lazy_log(LOGGER, logging.DEBUG, lambda: f"JobTracker - Thread {threading.get_native_id()} has acquired {intent}!")
+            lazy_log(
+                LOGGER,
+                logging.DEBUG,
+                lambda: f"JobTracker - Thread {threading.get_native_id()} has acquired {intent}!",
+            )
             self._jobs.add(intent)
             return intent
 
     def add_job(self, intent_or_job_id: str, job_id: str) -> None:
         if intent_or_job_id not in self._jobs:
-            raise ValueError(f"Can't add job: Unknown intent or job id, known values are {self._jobs}")
+            raise ValueError(
+                f"Can't add job: Unknown intent or job id, known values are {self._jobs}"
+            )
 
         if intent_or_job_id == job_id:
             # Nothing to do here as the ID to replace is the same
             return
 
         lazy_log(
-            LOGGER, logging.DEBUG, lambda: f"JobTracker - Thread {threading.get_native_id()} replacing job {intent_or_job_id} by {job_id}!"
+            LOGGER,
+            logging.DEBUG,
+            lambda: f"JobTracker - Thread {threading.get_native_id()} replacing job {intent_or_job_id} by {job_id}!",
         )
         with self._lock:
             self._jobs.add(job_id)
@@ -49,7 +63,11 @@ class JobTracker:
         """
         If the job is not allocated as a running job, this method does nothing and it won't raise.
         """
-        lazy_log(LOGGER, logging.DEBUG, lambda: f"JobTracker - Thread {threading.get_native_id()} removing job {job_id}")
+        lazy_log(
+            LOGGER,
+            logging.DEBUG,
+            lambda: f"JobTracker - Thread {threading.get_native_id()} removing job {job_id}",
+        )
         with self._lock:
             self._jobs.discard(job_id)
 

airbyte_cdk/sources/declarative/async_job/repository.py

@@ -26,7 +26,9 @@ class AsyncJobRepository:
         Called when we need to stop on the API side. This method can raise NotImplementedError as not all the APIs will support aborting
         jobs.
         """
-        raise NotImplementedError("Either the API or the AsyncJobRepository implementation do not support aborting jobs")
+        raise NotImplementedError(
+            "Either the API or the AsyncJobRepository implementation do not support aborting jobs"
+        )
 
     @abstractmethod
     def delete(self, job: AsyncJob) -> None:

airbyte_cdk/sources/declarative/auth/declarative_authenticator.py

@@ -5,7 +5,9 @@
 from dataclasses import InitVar, dataclass
 from typing import Any, Mapping, Union
 
-from airbyte_cdk.sources.streams.http.requests_native_auth.abstract_token import AbstractHeaderAuthenticator
+from airbyte_cdk.sources.streams.http.requests_native_auth.abstract_token import (
+    AbstractHeaderAuthenticator,
+)
 
 
 @dataclass

airbyte_cdk/sources/declarative/auth/jwt.py

@@ -75,22 +75,32 @@ class JwtAuthenticator(DeclarativeAuthenticator):
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._secret_key = InterpolatedString.create(self.secret_key, parameters=parameters)
-        self._algorithm = JwtAlgorithm(self.algorithm) if isinstance(self.algorithm, str) else self.algorithm
+        self._algorithm = (
+            JwtAlgorithm(self.algorithm) if isinstance(self.algorithm, str) else self.algorithm
+        )
         self._base64_encode_secret_key = (
             InterpolatedBoolean(self.base64_encode_secret_key, parameters=parameters)
             if isinstance(self.base64_encode_secret_key, str)
             else self.base64_encode_secret_key
         )
         self._token_duration = self.token_duration
-        self._header_prefix = InterpolatedString.create(self.header_prefix, parameters=parameters) if self.header_prefix else None
+        self._header_prefix = (
+            InterpolatedString.create(self.header_prefix, parameters=parameters)
+            if self.header_prefix
+            else None
+        )
         self._kid = InterpolatedString.create(self.kid, parameters=parameters) if self.kid else None
         self._typ = InterpolatedString.create(self.typ, parameters=parameters) if self.typ else None
         self._cty = InterpolatedString.create(self.cty, parameters=parameters) if self.cty else None
         self._iss = InterpolatedString.create(self.iss, parameters=parameters) if self.iss else None
         self._sub = InterpolatedString.create(self.sub, parameters=parameters) if self.sub else None
         self._aud = InterpolatedString.create(self.aud, parameters=parameters) if self.aud else None
-        self._additional_jwt_headers = InterpolatedMapping(self.additional_jwt_headers or {}, parameters=parameters)
-        self._additional_jwt_payload = InterpolatedMapping(self.additional_jwt_payload or {}, parameters=parameters)
+        self._additional_jwt_headers = InterpolatedMapping(
+            self.additional_jwt_headers or {}, parameters=parameters
+        )
+        self._additional_jwt_payload = InterpolatedMapping(
+            self.additional_jwt_payload or {}, parameters=parameters
+        )
 
     def _get_jwt_headers(self) -> dict[str, Any]:
         """ "
@@ -98,7 +108,9 @@ class JwtAuthenticator(DeclarativeAuthenticator):
         """
         headers = self._additional_jwt_headers.eval(self.config)
         if any(prop in headers for prop in ["kid", "alg", "typ", "cty"]):
-            raise ValueError("'kid', 'alg', 'typ', 'cty' are reserved headers and should not be set as part of 'additional_jwt_headers'")
+            raise ValueError(
+                "'kid', 'alg', 'typ', 'cty' are reserved headers and should not be set as part of 'additional_jwt_headers'"
+            )
 
         if self._kid:
             headers["kid"] = self._kid.eval(self.config)
@@ -139,7 +151,11 @@ class JwtAuthenticator(DeclarativeAuthenticator):
         Returns the secret key used to sign the JWT.
         """
         secret_key: str = self._secret_key.eval(self.config)
-        return base64.b64encode(secret_key.encode()).decode() if self._base64_encode_secret_key else secret_key
+        return (
+            base64.b64encode(secret_key.encode()).decode()
+            if self._base64_encode_secret_key
+            else secret_key
+        )
 
     def _get_signed_token(self) -> Union[str, Any]:
         """
@@ -167,4 +183,8 @@ class JwtAuthenticator(DeclarativeAuthenticator):
 
     @property
     def token(self) -> str:
-        return f"{self._get_header_prefix()} {self._get_signed_token()}" if self._get_header_prefix() else self._get_signed_token()
+        return (
+            f"{self._get_header_prefix()} {self._get_signed_token()}"
+            if self._get_header_prefix()
+            else self._get_signed_token()
+        )

airbyte_cdk/sources/declarative/auth/oauth.py

@@ -10,8 +10,12 @@ from airbyte_cdk.sources.declarative.auth.declarative_authenticator import Decla
 from airbyte_cdk.sources.declarative.interpolation.interpolated_mapping import InterpolatedMapping
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
-from airbyte_cdk.sources.streams.http.requests_native_auth.abstract_oauth import AbstractOauth2Authenticator
-from airbyte_cdk.sources.streams.http.requests_native_auth.oauth import SingleUseRefreshTokenOauth2Authenticator
+from airbyte_cdk.sources.streams.http.requests_native_auth.abstract_oauth import (
+    AbstractOauth2Authenticator,
+)
+from airbyte_cdk.sources.streams.http.requests_native_auth.oauth import (
+    SingleUseRefreshTokenOauth2Authenticator,
+)
 
 
 @dataclass
@@ -57,31 +61,49 @@ class DeclarativeOauth2Authenticator(AbstractOauth2Authenticator, DeclarativeAut
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         super().__init__()
-        self._token_refresh_endpoint = InterpolatedString.create(self.token_refresh_endpoint, parameters=parameters)
+        self._token_refresh_endpoint = InterpolatedString.create(
+            self.token_refresh_endpoint, parameters=parameters
+        )
         self._client_id = InterpolatedString.create(self.client_id, parameters=parameters)
         self._client_secret = InterpolatedString.create(self.client_secret, parameters=parameters)
         if self.refresh_token is not None:
-            self._refresh_token: Optional[InterpolatedString] = InterpolatedString.create(self.refresh_token, parameters=parameters)
+            self._refresh_token: Optional[InterpolatedString] = InterpolatedString.create(
+                self.refresh_token, parameters=parameters
+            )
         else:
             self._refresh_token = None
-        self.access_token_name = InterpolatedString.create(self.access_token_name, parameters=parameters)
-        self.expires_in_name = InterpolatedString.create(self.expires_in_name, parameters=parameters)
+        self.access_token_name = InterpolatedString.create(
+            self.access_token_name, parameters=parameters
+        )
+        self.expires_in_name = InterpolatedString.create(
+            self.expires_in_name, parameters=parameters
+        )
         self.grant_type = InterpolatedString.create(self.grant_type, parameters=parameters)
-        self._refresh_request_body = InterpolatedMapping(self.refresh_request_body or {}, parameters=parameters)
+        self._refresh_request_body = InterpolatedMapping(
+            self.refresh_request_body or {}, parameters=parameters
+        )
         self._token_expiry_date: pendulum.DateTime = (
-            pendulum.parse(InterpolatedString.create(self.token_expiry_date, parameters=parameters).eval(self.config))  # type: ignore # pendulum.parse returns a datetime in this context
+            pendulum.parse(
+                InterpolatedString.create(self.token_expiry_date, parameters=parameters).eval(
+                    self.config
+                )
+            )  # type: ignore # pendulum.parse returns a datetime in this context
             if self.token_expiry_date
             else pendulum.now().subtract(days=1)  # type: ignore # substract does not have type hints
         )
         self._access_token: Optional[str] = None  # access_token is initialized by a setter
 
         if self.get_grant_type() == "refresh_token" and self._refresh_token is None:
-            raise ValueError("OAuthAuthenticator needs a refresh_token parameter if grant_type is set to `refresh_token`")
+            raise ValueError(
+                "OAuthAuthenticator needs a refresh_token parameter if grant_type is set to `refresh_token`"
+            )
 
     def get_token_refresh_endpoint(self) -> str:
         refresh_token: str = self._token_refresh_endpoint.eval(self.config)
         if not refresh_token:
-            raise ValueError("OAuthAuthenticator was unable to evaluate token_refresh_endpoint parameter")
+            raise ValueError(
+                "OAuthAuthenticator was unable to evaluate token_refresh_endpoint parameter"
+            )
         return refresh_token
 
     def get_client_id(self) -> str:
@@ -139,7 +161,9 @@ class DeclarativeOauth2Authenticator(AbstractOauth2Authenticator, DeclarativeAut
 
 
 @dataclass
-class DeclarativeSingleUseRefreshTokenOauth2Authenticator(SingleUseRefreshTokenOauth2Authenticator, DeclarativeAuthenticator):
+class DeclarativeSingleUseRefreshTokenOauth2Authenticator(
+    SingleUseRefreshTokenOauth2Authenticator, DeclarativeAuthenticator
+):
     """
     Declarative version of SingleUseRefreshTokenOauth2Authenticator which can be used in declarative connectors.
     """

airbyte_cdk/sources/declarative/auth/selective_authenticator.py

@@ -29,7 +29,9 @@ class SelectiveAuthenticator(DeclarativeAuthenticator):
         try:
             selected_key = str(dpath.get(config, authenticator_selection_path))
         except KeyError as err:
-            raise ValueError("The path from `authenticator_selection_path` is not found in the config.") from err
+            raise ValueError(
+                "The path from `authenticator_selection_path` is not found in the config."
+            ) from err
 
         try:
             return authenticators[selected_key]

airbyte_cdk/sources/declarative/auth/token.py

@@ -11,7 +11,10 @@ import requests
 from airbyte_cdk.sources.declarative.auth.declarative_authenticator import DeclarativeAuthenticator
 from airbyte_cdk.sources.declarative.auth.token_provider import TokenProvider
 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_option import (
+    RequestOption,
+    RequestOptionType,
+)
 from airbyte_cdk.sources.types import Config
 from cachetools import TTLCache, cached
 
@@ -42,7 +45,9 @@ class ApiKeyAuthenticator(DeclarativeAuthenticator):
     parameters: InitVar[Mapping[str, Any]]
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-        self._field_name = InterpolatedString.create(self.request_option.field_name, parameters=parameters)
+        self._field_name = InterpolatedString.create(
+            self.request_option.field_name, parameters=parameters
+        )
 
     @property
     def auth_header(self) -> str:
@@ -127,7 +132,9 @@ class BasicHttpAuthenticator(DeclarativeAuthenticator):
 
     @property
     def token(self) -> str:
-        auth_string = f"{self._username.eval(self.config)}:{self._password.eval(self.config)}".encode("utf8")
+        auth_string = (
+            f"{self._username.eval(self.config)}:{self._password.eval(self.config)}".encode("utf8")
+        )
         b64_encoded = base64.b64encode(auth_string).decode("utf8")
         return f"Basic {b64_encoded}"
 
@@ -164,7 +171,9 @@ def get_new_session_token(api_url: str, username: str, password: str, response_k
     )
     response.raise_for_status()
     if not response.ok:
-        raise ConnectionError(f"Failed to retrieve new session token, response code {response.status_code} because {response.reason}")
+        raise ConnectionError(
+            f"Failed to retrieve new session token, response code {response.status_code} because {response.reason}"
+        )
     return str(response.json()[response_key])
 
 
@@ -208,9 +217,13 @@ class LegacySessionTokenAuthenticator(DeclarativeAuthenticator):
         self._api_url = InterpolatedString.create(self.api_url, parameters=parameters)
         self._header = InterpolatedString.create(self.header, parameters=parameters)
         self._session_token = InterpolatedString.create(self.session_token, parameters=parameters)
-        self._session_token_response_key = InterpolatedString.create(self.session_token_response_key, parameters=parameters)
+        self._session_token_response_key = InterpolatedString.create(
+            self.session_token_response_key, parameters=parameters
+        )
         self._login_url = InterpolatedString.create(self.login_url, parameters=parameters)
-        self._validate_session_url = InterpolatedString.create(self.validate_session_url, parameters=parameters)
+        self._validate_session_url = InterpolatedString.create(
+            self.validate_session_url, parameters=parameters
+        )
 
         self.logger = logging.getLogger("airbyte")
 
@@ -232,7 +245,9 @@ class LegacySessionTokenAuthenticator(DeclarativeAuthenticator):
             self.logger.info("Using generated session token by username and password")
             return get_new_session_token(api_url, username, password, session_token_response_key)
 
-        raise ConnectionError("Invalid credentials: session token is not valid or provide username and password")
+        raise ConnectionError(
+            "Invalid credentials: session token is not valid or provide username and password"
+        )
 
     def is_valid_session_token(self) -> bool:
         try:
@@ -251,4 +266,6 @@ class LegacySessionTokenAuthenticator(DeclarativeAuthenticator):
             self.logger.info("Connection check for source is successful.")
             return True
         else:
-            raise ConnectionError(f"Failed to retrieve new session token, response code {response.status_code} because {response.reason}")
+            raise ConnectionError(
+                f"Failed to retrieve new session token, response code {response.status_code} because {response.reason}"
+            )

airbyte_cdk/sources/declarative/checks/check_stream.py

@@ -27,22 +27,30 @@ class CheckStream(ConnectionChecker):
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._parameters = parameters
 
-    def check_connection(self, source: AbstractSource, logger: logging.Logger, config: Mapping[str, Any]) -> Tuple[bool, Any]:
+    def check_connection(
+        self, source: AbstractSource, logger: logging.Logger, config: Mapping[str, Any]
+    ) -> Tuple[bool, Any]:
         streams = source.streams(config=config)
         stream_name_to_stream = {s.name: s for s in streams}
         if len(streams) == 0:
             return False, f"No streams to connect to from source {source}"
         for stream_name in self.stream_names:
             if stream_name not in stream_name_to_stream.keys():
-                raise ValueError(f"{stream_name} is not part of the catalog. Expected one of {stream_name_to_stream.keys()}.")
+                raise ValueError(
+                    f"{stream_name} is not part of the catalog. Expected one of {stream_name_to_stream.keys()}."
+                )
 
             stream = stream_name_to_stream[stream_name]
             availability_strategy = HttpAvailabilityStrategy()
             try:
-                stream_is_available, reason = availability_strategy.check_availability(stream, logger)
+                stream_is_available, reason = availability_strategy.check_availability(
+                    stream, logger
+                )
                 if not stream_is_available:
                     return False, reason
             except Exception as error:
-                logger.error(f"Encountered an error trying to connect to stream {stream_name}. Error: \n {traceback.format_exc()}")
+                logger.error(
+                    f"Encountered an error trying to connect to stream {stream_name}. Error: \n {traceback.format_exc()}"
+                )
                 return False, f"Unable to connect to stream {stream_name} - {error}"
         return True, None