airbyte-cdk 0.72.1__py3-none-any.whl → 6.13.1.dev4107__py3-none-any.whl

airbyte_cdk/sources/singer/singer_helpers.py

@@ -1,304 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-import json
-import os
-import selectors
-import subprocess
-from dataclasses import dataclass
-from datetime import datetime
-from io import TextIOWrapper
-from typing import Any, DefaultDict, Dict, Iterator, List, Mapping, Optional, Tuple
-
-from airbyte_cdk.logger import log_by_prefix
-from airbyte_cdk.models import (
-    AirbyteCatalog,
-    AirbyteMessage,
-    AirbyteRecordMessage,
-    AirbyteStateMessage,
-    AirbyteStream,
-    ConfiguredAirbyteCatalog,
-    ConfiguredAirbyteStream,
-    SyncMode,
-    Type,
-)
-
-_INCREMENTAL = "INCREMENTAL"
-_FULL_TABLE = "FULL_TABLE"
-
-
-def to_json(string):
-    try:
-        return json.loads(string)
-    except ValueError:
-        return False
-
-
-def is_field_metadata(metadata):
-    if len(metadata.get("breadcrumb")) != 2:
-        return False
-    else:
-        return metadata.get("breadcrumb")[0] != "property"
-
-
-def configured_for_incremental(configured_stream: ConfiguredAirbyteStream):
-    return configured_stream.sync_mode and configured_stream.sync_mode == SyncMode.incremental
-
-
-def get_stream_level_metadata(metadatas: List[Dict[str, Any]]) -> Optional[Dict[str, Any]]:
-    for metadata in metadatas:
-        if not is_field_metadata(metadata) and "metadata" in metadata:
-            return metadata.get("metadata")
-    return None
-
-
-@dataclass
-class Catalogs:
-    singer_catalog: object
-    airbyte_catalog: AirbyteCatalog
-
-
-@dataclass
-class SyncModeInfo:
-    supported_sync_modes: Optional[List[SyncMode]] = None
-    source_defined_cursor: Optional[bool] = None
-    default_cursor_field: Optional[List[str]] = None
-
-
-def set_sync_modes_from_metadata(airbyte_stream: AirbyteStream, metadatas: List[Dict[str, Any]]):
-    stream_metadata = get_stream_level_metadata(metadatas)
-    if stream_metadata:
-        # A stream is incremental if it declares replication keys or if forced-replication-method is set to incremental
-        replication_keys = stream_metadata.get("valid-replication-keys", [])
-        if len(replication_keys) > 0:
-            airbyte_stream.source_defined_cursor = True
-            airbyte_stream.supported_sync_modes = [SyncMode.incremental]
-            # TODO if there are multiple replication keys, allow configuring which one is used. For now we deterministically take the first
-            airbyte_stream.default_cursor_field = [sorted(replication_keys)[0]]
-        elif "forced-replication-method" in stream_metadata:
-            forced_replication_method = stream_metadata["forced-replication-method"]
-            if isinstance(forced_replication_method, dict):
-                forced_replication_method = forced_replication_method.get("replication-method", "")
-            if forced_replication_method.upper() == _INCREMENTAL:
-                airbyte_stream.source_defined_cursor = True
-                airbyte_stream.supported_sync_modes = [SyncMode.incremental]
-            elif forced_replication_method.upper() == _FULL_TABLE:
-                airbyte_stream.source_defined_cursor = False
-                airbyte_stream.supported_sync_modes = [SyncMode.full_refresh]
-
-
-def override_sync_modes(airbyte_stream: AirbyteStream, overrides: SyncModeInfo):
-    airbyte_stream.source_defined_cursor = overrides.source_defined_cursor or False
-    if overrides.supported_sync_modes:
-        airbyte_stream.supported_sync_modes = overrides.supported_sync_modes
-    if overrides.default_cursor_field is not None:
-        airbyte_stream.default_cursor_field = overrides.default_cursor_field
-
-
-class SingerHelper:
-    @staticmethod
-    def _transform_types(stream_properties: DefaultDict):
-        for field_name in stream_properties:
-            field_object = stream_properties[field_name]
-            # according to issue CDK: typing errors #9500, mypy raises error on this line
-            # '"Type[SingerHelper]" has no attribute "_parse_type"', it's need to fix
-            # ignored for now
-            field_object["type"] = SingerHelper._parse_type(field_object["type"])  # type: ignore
-
-    @staticmethod
-    def singer_catalog_to_airbyte_catalog(
-        singer_catalog: Dict[str, Any], sync_mode_overrides: Dict[str, SyncModeInfo], primary_key_overrides: Dict[str, List[str]]
-    ) -> AirbyteCatalog:
-        """
-        :param singer_catalog:
-        :param sync_mode_overrides: A dict from stream name to the sync modes it should use. Each stream in this dict must exist in the Singer catalog,
-          but not every stream in the catalog should exist in this
-        :param primary_key_overrides: A dict of stream name -> list of fields to be used as PKs.
-        :return: Airbyte Catalog
-        """
-        airbyte_streams = []
-        # according to issue CDK: typing errors #9500, mypy raises error on this line
-        # 'Item "None" of "Optional[Any]" has no attribute "__iter__" (not iterable)'
-        # It occurs because default value isn't set, and it's None
-        # It's needed to set default value, ignored for now
-        for stream in singer_catalog.get("streams"):  # type: ignore
-            name = stream.get("stream")
-            schema = stream.get("schema")
-            airbyte_stream = AirbyteStream(name=name, json_schema=schema, supported_sync_modes=[SyncMode.full_refresh])
-            if name in sync_mode_overrides:
-                override_sync_modes(airbyte_stream, sync_mode_overrides[name])
-            else:
-                set_sync_modes_from_metadata(airbyte_stream, stream.get("metadata", []))
-
-            if name in primary_key_overrides:
-                airbyte_stream.source_defined_primary_key = [[k] for k in primary_key_overrides[name]]
-            elif stream.get("key_properties"):
-                airbyte_stream.source_defined_primary_key = [[k] for k in stream["key_properties"]]
-
-            airbyte_streams += [airbyte_stream]
-        return AirbyteCatalog(streams=airbyte_streams)
-
-    @staticmethod
-    def _read_singer_catalog(logger, shell_command: str) -> Mapping[str, Any]:
-        completed_process = subprocess.run(
-            shell_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True
-        )
-        for line in completed_process.stderr.splitlines():
-            logger.log(*log_by_prefix(line, "ERROR"))
-
-        return json.loads(completed_process.stdout)
-
-    @staticmethod
-    def get_catalogs(
-        logger,
-        shell_command: str,
-        sync_mode_overrides: Dict[str, SyncModeInfo],
-        primary_key_overrides: Dict[str, List[str]],
-        excluded_streams: List,
-    ) -> Catalogs:
-        singer_catalog = SingerHelper._read_singer_catalog(logger, shell_command)
-        streams = singer_catalog.get("streams", [])
-        if streams and excluded_streams:
-            # according to issue CDK: typing errors #9500, mypy raises error on this line
-            # 'Unsupported target for indexed assignment ("Mapping[str, Any]")'
-            # _read_singer_catalog returns Mapping, to fix this error it should be changed to MutableMapping
-            # ignored for now
-            singer_catalog["streams"] = [stream for stream in streams if stream["stream"] not in excluded_streams]  # type: ignore
-
-        # according to issue CDK: typing errors #9500, mypy raises error on this line
-        # 'Argument 1 to "singer_catalog_to_airbyte_catalog" of "SingerHelper" has incompatible type "Mapping[str, Any]"; expected "Dict[str, Any]"'
-        # singer_catalog is Mapping, because _read_singer_catalog returns Mapping, but singer_catalog_to_airbyte_catalog expects Dict
-        # it's needed to check and fix, ignored for now
-        airbyte_catalog = SingerHelper.singer_catalog_to_airbyte_catalog(singer_catalog, sync_mode_overrides, primary_key_overrides)  # type: ignore
-        return Catalogs(singer_catalog=singer_catalog, airbyte_catalog=airbyte_catalog)
-
-    @staticmethod
-    def read(logger, shell_command, is_message=(lambda x: True)) -> Iterator[AirbyteMessage]:
-        with subprocess.Popen(shell_command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, universal_newlines=True) as p:
-            for line, text_wrapper in SingerHelper._read_lines(p):
-                if text_wrapper is p.stdout:
-                    out_json = to_json(line)
-                    if out_json is not None and is_message(out_json):
-                        message_data = SingerHelper._airbyte_message_from_json(out_json)
-                        if message_data is not None:
-                            yield message_data
-                    else:
-                        logger.log(*log_by_prefix(line, "INFO"))
-                else:
-                    logger.log(*log_by_prefix(line, "ERROR"))
-
-    @staticmethod
-    def _read_lines(process: subprocess.Popen) -> Iterator[Tuple[str, TextIOWrapper]]:
-        sel = selectors.DefaultSelector()
-        # according to issue CDK: typing errors #9500, mypy raises error on this two lines
-        # 'Argument 1 to "register" of "DefaultSelector" has incompatible type "Optional[IO[Any]]"; expected "Union[int, HasFileno]"'
-        # 'Argument 1 to "register" of "DefaultSelector" has incompatible type "Optional[IO[Any]]"; expected "Union[int, HasFileno]"'
-        # It's need to check, ignored for now
-        sel.register(process.stdout, selectors.EVENT_READ)  # type: ignore
-        sel.register(process.stderr, selectors.EVENT_READ)  # type: ignore
-        eof = False
-        while not eof:
-            selects_list = sel.select()
-            empty_line_counter = 0
-            for key, _ in selects_list:
-                # according to issue CDK: typing errors #9500, mypy raises two errors on these lines
-                # 'Item "int" of "Union[int, HasFileno]" has no attribute "readline"'
-                # 'Item "HasFileno" of "Union[int, HasFileno]" has no attribute "readline"'
-                # It's need to check, ignored for now
-                line = key.fileobj.readline()  # type: ignore
-                if not line:
-                    empty_line_counter += 1
-                    if empty_line_counter >= len(selects_list):
-                        eof = True
-
-                        try:
-                            process.wait(timeout=60)
-                        except subprocess.TimeoutExpired:
-                            # according to issue CDK: typing errors #9500, mypy raises error on this line
-                            # 'On Python 3 '{}'.format(b'abc') produces "b'abc'", not 'abc'; use '{!r}'.format(b'abc') if this is desired behavior'
-                            # It's need to fix, ignored for now
-                            raise Exception(f"Underlying command {process.args} is hanging")  # type: ignore
-
-                        if process.returncode != 0:
-                            # according to issue CDK: typing errors #9500, mypy raises error on this line
-                            # 'On Python 3 '{}'.format(b'abc') produces "b'abc'", not 'abc'; use '{!r}'.format(b'abc') if this is desired behavior'
-                            # It's need to fix, ignored for now
-                            raise Exception(f"Underlying command {process.args} failed with exit code {process.returncode}")  # type: ignore
-                else:
-                    # according to issue CDK: typing errors #9500, mypy raises error on this line
-                    # 'Incompatible types in "yield" (actual type "Tuple[Any, Union[int, HasFileno]]", expected type "Tuple[str, TextIOWrapper]")'
-                    # It's need to fix, ignored for now
-                    yield line, key.fileobj  # type: ignore
-
-    @staticmethod
-    def _airbyte_message_from_json(transformed_json: Mapping[str, Any]) -> Optional[AirbyteMessage]:
-        if transformed_json is None or transformed_json.get("type") == "SCHEMA" or transformed_json.get("type") == "ACTIVATE_VERSION":
-            return None
-        elif transformed_json.get("type") == "STATE":
-            out_record = AirbyteStateMessage(data=transformed_json["value"])
-            out_message = AirbyteMessage(type=Type.STATE, state=out_record)
-        else:
-            # todo: check that messages match the discovered schema
-            stream_name = transformed_json["stream"]
-            # according to issue CDK: typing errors #9500, mypy raises error on this line
-            # 'Incompatible types in assignment (expression has type "AirbyteRecordMessage", variable has type "AirbyteStateMessage")'
-            # type of out_record is first initialized as AirbyteStateMessage on the line 240
-            # however AirbyteRecordMessage is assigned on the line below, it causes error
-            # ignored
-            out_record = AirbyteRecordMessage(  # type: ignore
-                stream=stream_name,
-                data=transformed_json["record"],
-                emitted_at=int(datetime.now().timestamp()) * 1000,
-            )
-            out_message = AirbyteMessage(type=Type.RECORD, record=out_record)
-        return out_message
-
-    @staticmethod
-    def create_singer_catalog_with_selection(masked_airbyte_catalog: ConfiguredAirbyteCatalog, discovered_singer_catalog: object) -> str:
-        combined_catalog_path = os.path.join("singer_rendered_catalog.json")
-        masked_singer_streams = []
-
-        stream_name_to_configured_stream = {
-            configured_stream.stream.name: configured_stream for configured_stream in masked_airbyte_catalog.streams
-        }
-
-        # according to issue CDK: typing errors #9500, mypy raises error on this line
-        # '"object" has no attribute "get"'
-        # discovered_singer_catalog type is set to object on the line 259, need to check
-        # ignored for now
-        for singer_stream in discovered_singer_catalog.get("streams"):  # type: ignore
-            stream_name = singer_stream.get("stream")
-            if stream_name in stream_name_to_configured_stream:
-                new_metadatas = []
-                # support old style catalog.
-                singer_stream["schema"]["selected"] = True
-                if singer_stream.get("metadata"):
-                    metadatas = singer_stream.get("metadata")
-                    for metadata in metadatas:
-                        new_metadata = metadata
-                        new_metadata["metadata"]["selected"] = True
-                        if not is_field_metadata(new_metadata):
-                            configured_stream = stream_name_to_configured_stream[stream_name]
-                            if configured_for_incremental(configured_stream):
-                                replication_method = _INCREMENTAL
-                                if configured_stream.cursor_field:
-                                    new_metadata["metadata"]["replication-key"] = configured_stream.cursor_field[0]
-                            else:
-                                replication_method = _FULL_TABLE
-                            new_metadata["metadata"]["forced-replication-method"] = replication_method
-                            new_metadata["metadata"]["replication-method"] = replication_method
-                        else:
-                            if "fieldExclusions" in new_metadata["metadata"]:
-                                new_metadata["metadata"]["selected"] = True if not new_metadata["metadata"]["fieldExclusions"] else False
-                        new_metadatas += [new_metadata]
-                    singer_stream["metadata"] = new_metadatas
-
-            masked_singer_streams += [singer_stream]
-
-        combined_catalog = {"streams": masked_singer_streams}
-        with open(combined_catalog_path, "w") as fh:
-            fh.write(json.dumps(combined_catalog))
-
-        return combined_catalog_path

airbyte_cdk/sources/singer/source.py

@@ -1,186 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-import logging
-import os
-from typing import Any, Dict, Iterable, List, Mapping, Type
-
-from airbyte_cdk.models import AirbyteCatalog, AirbyteConnectionStatus, AirbyteMessage, ConfiguredAirbyteCatalog, Status
-from airbyte_cdk.sources.source import BaseSource
-from airbyte_cdk.sources.utils.catalog_helpers import CatalogHelper
-
-from .singer_helpers import Catalogs, SingerHelper, SyncModeInfo
-
-
-class ConfigContainer(Dict[str, Any]):
-    config_path: str
-
-    def __init__(self, config, config_path):
-        super().__init__(config)
-        self.config_path = config_path
-
-
-class SingerSource(BaseSource[ConfigContainer, str, str]):
-    def configure(self, config: Mapping[str, Any], temp_dir: str) -> ConfigContainer:
-        """
-        Persist raw_config in temporary directory to run the Source job
-        This can be overridden if extra temporary files need to be persisted in the temp dir
-        """
-        config_path = os.path.join(temp_dir, "config.json")
-        config = ConfigContainer(self.transform_config(config), config_path)
-        self.write_config(config, config_path)
-        return config
-
-    # Can be overridden to change an input config
-    def transform_config(self, config: Mapping[str, Any]) -> Mapping[str, Any]:
-        """
-        Singer source may need to adapt the Config object for the singer tap specifics
-        """
-        return config
-
-    def read_catalog(self, catalog_path: str) -> str:
-        """
-        Since singer source don't need actual catalog object, we override this to return path only
-        """
-        return catalog_path
-
-    def read_state(self, state_path: str) -> str:
-        """
-        Since singer source don't need actual state object, we override this to return path only
-        """
-        return state_path
-
-    def check_config(self, logger: logging.Logger, config_path: str, config: ConfigContainer) -> AirbyteConnectionStatus:
-        """
-        Some Singer source may perform check using config_path or config to
-        tests if the input configuration can be used to successfully connect to the integration
-        """
-        raise NotImplementedError
-
-    def discover_cmd(self, logger: logging.Logger, config_path: str) -> str:
-        """
-        Returns the command used to run discovery in the singer tap. For example, if the bash command used to invoke the singer tap is `tap-postgres`,
-        and the config JSON lived in "/path/config.json", this method would return "tap-postgres --config /path/config.json"
-        """
-        raise NotImplementedError
-
-    def read_cmd(self, logger: logging.Logger, config_path: str, catalog_path: str, state_path: str = None) -> str:
-        """
-        Returns the command used to read data from the singer tap. For example, if the bash command used to invoke the singer tap is `tap-postgres`,
-        and the config JSON lived in "/path/config.json", and the catalog was in "/path/catalog.json",
-        this method would return "tap-postgres --config /path/config.json --catalog /path/catalog.json"
-        """
-        raise NotImplementedError
-
-    def _discover_internal(self, logger: logging.Logger, config_path: str) -> Catalogs:
-        cmd = self.discover_cmd(logger, config_path)
-        catalogs = SingerHelper.get_catalogs(
-            logger, cmd, self.get_sync_mode_overrides(), self.get_primary_key_overrides(), self.get_excluded_streams()
-        )
-        return catalogs
-
-    def check(self, logger: logging.Logger, config: ConfigContainer) -> AirbyteConnectionStatus:
-        """
-        Tests if the input configuration can be used to successfully connect to the integration
-        """
-        return self.check_config(logger, config.config_path, config)
-
-    def discover(self, logger: logging.Logger, config: ConfigContainer) -> AirbyteCatalog:
-        """
-        Implements the parent class discover method.
-        """
-        return self._discover_internal(logger, config.config_path).airbyte_catalog
-
-    def read(self, logger: logging.Logger, config: ConfigContainer, catalog_path: str, state_path: str = None) -> Iterable[AirbyteMessage]:
-        """
-        Implements the parent class read method.
-        """
-        catalogs = self._discover_internal(logger, config.config_path)
-        masked_airbyte_catalog = ConfiguredAirbyteCatalog.parse_obj(self._read_json_file(catalog_path))
-        selected_singer_catalog_path = SingerHelper.create_singer_catalog_with_selection(masked_airbyte_catalog, catalogs.singer_catalog)
-
-        read_cmd = self.read_cmd(logger, config.config_path, selected_singer_catalog_path, state_path)
-        return SingerHelper.read(logger, read_cmd)
-
-    def get_sync_mode_overrides(self) -> Dict[str, SyncModeInfo]:
-        """
-        The Singer Spec outlines a way for taps to declare in their catalog that their streams support incremental sync (valid-replication-keys,
-        forced-replication-method, and others). However, many taps which are incremental don't actually declare that via the catalog, and just
-        use their input state to perform an incremental sync without giving any hints to the user. An Airbyte Connector built on top of such a
-        Singer Tap cannot automatically detect which streams are full refresh or incremental or what their cursors are. In those cases the developer
-        needs to manually specify information about the sync modes.
-
-        This method provides a way of doing that: the dict of stream names to SyncModeInfo returned from this method will be used to override each
-        stream's sync mode information in the Airbyte Catalog output from the discover method. Only set fields provided in the SyncModeInfo are used.
-        If a SyncModeInfo field is not set, it will not be overridden in the output catalog.
-
-        :return: A dict from stream name to the sync modes that should be applied to this stream.
-        """
-        return {}
-
-    def get_primary_key_overrides(self) -> Dict[str, List[str]]:
-        """
-        Similar to get_sync_mode_overrides but for primary keys.
-
-        :return: A dict from stream name to the list of primary key fields for the stream.
-        """
-        return {}
-
-    def get_excluded_streams(self) -> List[str]:
-        """
-        This method provide ability to exclude some streams from catalog
-
-        :return: A list of excluded stream names
-        """
-        return []
-
-
-class BaseSingerSource(SingerSource):
-    force_full_refresh = False
-
-    def check_config(self, logger: logging.Logger, config_path: str, config: Mapping[str, Any]) -> AirbyteConnectionStatus:
-        try:
-            self.try_connect(logger, config)
-        except self.api_error as err:
-            logger.error(f"Exception while connecting to {self.tap_name}: {err}")
-            # this should be in UI
-            error_msg = f"Unable to connect to {self.tap_name} with the provided credentials. Error: {err}"
-            return AirbyteConnectionStatus(status=Status.FAILED, message=error_msg)
-        return AirbyteConnectionStatus(status=Status.SUCCEEDED)
-
-    def discover_cmd(self, logger: logging.Logger, config_path: str) -> str:
-        return f"{self.tap_cmd} --config {config_path} --discover"
-
-    def read_cmd(self, logger: logging.Logger, config_path: str, catalog_path: str, state_path: str = None) -> str:
-        state_path = None if self.force_full_refresh else state_path
-        args = {"--config": config_path, "--catalog": catalog_path, "--state": state_path}
-        cmd = " ".join([f"{k} {v}" for k, v in args.items() if v is not None])
-
-        return f"{self.tap_cmd} {cmd}"
-
-    def discover(self, logger: logging.Logger, config: ConfigContainer) -> AirbyteCatalog:
-        catalog = super().discover(logger, config)
-        if self.force_full_refresh:
-            return CatalogHelper.coerce_catalog_as_full_refresh(catalog)
-        return catalog
-
-    def try_connect(self, logger: logging.Logger, config: Mapping[str, Any]):
-        """Test provided credentials, raises self.api_error if something goes wrong"""
-        raise NotImplementedError
-
-    @property
-    def api_error(self) -> Type[Exception]:
-        """Class/Base class of the exception that will be thrown if the tap is misconfigured or service unavailable"""
-        raise NotImplementedError
-
-    @property
-    def tap_cmd(self) -> str:
-        """Tap command"""
-        raise NotImplementedError
-
-    @property
-    def tap_name(self) -> str:
-        """Tap name"""
-        raise NotImplementedError

airbyte_cdk/sources/streams/concurrent/partitions/record.py

@@ -1,23 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-from typing import Any, Mapping
-
-
-class Record:
-    """
-    Represents a record read from a stream.
-    """
-
-    def __init__(self, data: Mapping[str, Any], stream_name: str):
-        self.data = data
-        self.stream_name = stream_name
-
-    def __eq__(self, other: Any) -> bool:
-        if not isinstance(other, Record):
-            return False
-        return self.data == other.data and self.stream_name == other.stream_name
-
-    def __repr__(self) -> str:
-        return f"Record(data={self.data}, stream_name={self.stream_name})"

airbyte_cdk/sources/streams/http/auth/__init__.py

@@ -1,17 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-# Initialize Auth Package
-from .core import HttpAuthenticator, NoAuth
-from .oauth import Oauth2Authenticator
-from .token import BasicHttpAuthenticator, MultipleTokenAuthenticator, TokenAuthenticator
-
-__all__ = [
-    "BasicHttpAuthenticator",
-    "HttpAuthenticator",
-    "NoAuth",
-    "Oauth2Authenticator",
-    "TokenAuthenticator",
-    "MultipleTokenAuthenticator",
-]

airbyte_cdk/sources/streams/http/auth/core.py

@@ -1,29 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-from abc import ABC, abstractmethod
-from typing import Any, Mapping
-
-from deprecated import deprecated
-
-
-@deprecated(version="0.1.20", reason="Use requests.auth.AuthBase instead")
-class HttpAuthenticator(ABC):
-    """
-    Base abstract class for various HTTP Authentication strategies. Authentication strategies are generally
-    expected to provide security credentials via HTTP headers.
-    """
-
-    @abstractmethod
-    def get_auth_header(self) -> Mapping[str, Any]:
-        """
-        :return: A dictionary containing all the necessary headers to authenticate.
-        """
-
-
-@deprecated(version="0.1.20", reason="Set `authenticator=None` instead")
-class NoAuth(HttpAuthenticator):
-    def get_auth_header(self) -> Mapping[str, Any]:
-        return {}

airbyte_cdk/sources/streams/http/auth/oauth.py

@@ -1,113 +0,0 @@
-#
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
-#
-
-
-import logging
-from typing import Any, List, Mapping, MutableMapping, Optional, Tuple
-
-import backoff
-import pendulum
-import requests
-from deprecated import deprecated
-
-from ..exceptions import DefaultBackoffException
-from .core import HttpAuthenticator
-
-logger = logging.getLogger("airbyte")
-
-
-@deprecated(version="0.1.20", reason="Use airbyte_cdk.sources.streams.http.requests_native_auth.Oauth2Authenticator instead")
-class Oauth2Authenticator(HttpAuthenticator):
-    """
-    Generates OAuth2.0 access tokens from an OAuth2.0 refresh token and client credentials.
-    The generated access token is attached to each request via the Authorization header.
-    """
-
-    def __init__(
-        self,
-        token_refresh_endpoint: str,
-        client_id: str,
-        client_secret: str,
-        refresh_token: str,
-        scopes: List[str] = None,
-        refresh_access_token_headers: Optional[Mapping[str, Any]] = None,
-        refresh_access_token_authenticator: Optional[HttpAuthenticator] = None,
-    ):
-        self.token_refresh_endpoint = token_refresh_endpoint
-        self.client_secret = client_secret
-        self.client_id = client_id
-        self.refresh_token = refresh_token
-        self.scopes = scopes
-        self.refresh_access_token_headers = refresh_access_token_headers
-        self.refresh_access_token_authenticator = refresh_access_token_authenticator
-
-        self._token_expiry_date = pendulum.now().subtract(days=1)
-        self._access_token = None
-
-    def get_auth_header(self) -> Mapping[str, Any]:
-        return {"Authorization": f"Bearer {self.get_access_token()}"}
-
-    def get_access_token(self):
-        if self.token_has_expired():
-            t0 = pendulum.now()
-            token, expires_in = self.refresh_access_token()
-            self._access_token = token
-            self._token_expiry_date = t0.add(seconds=expires_in)
-
-        return self._access_token
-
-    def token_has_expired(self) -> bool:
-        return pendulum.now() > self._token_expiry_date
-
-    def get_refresh_request_body(self) -> Mapping[str, Any]:
-        """Override to define additional parameters"""
-        payload: MutableMapping[str, Any] = {
-            "grant_type": "refresh_token",
-            "client_id": self.client_id,
-            "client_secret": self.client_secret,
-            "refresh_token": self.refresh_token,
-        }
-
-        if self.scopes:
-            payload["scopes"] = self.scopes
-
-        return payload
-
-    @backoff.on_exception(
-        backoff.expo,
-        DefaultBackoffException,
-        on_backoff=lambda details: logger.info(
-            f"Caught retryable error after {details['tries']} tries. Waiting {details['wait']} seconds then retrying..."
-        ),
-        max_time=300,
-    )
-    def refresh_access_token(self) -> Tuple[str, int]:
-        """
-        returns a tuple of (access_token, token_lifespan_in_seconds)
-        """
-        try:
-            response = requests.request(
-                method="POST",
-                url=self.token_refresh_endpoint,
-                data=self.get_refresh_request_body(),
-                headers=self.get_refresh_access_token_headers(),
-            )
-            response.raise_for_status()
-            response_json = response.json()
-            return response_json["access_token"], int(response_json["expires_in"])
-        except requests.exceptions.RequestException as e:
-            if e.response.status_code == 429 or e.response.status_code >= 500:
-                raise DefaultBackoffException(request=e.response.request, response=e.response)
-            raise
-        except Exception as e:
-            raise Exception(f"Error while refreshing access token: {e}") from e
-
-    def get_refresh_access_token_headers(self):
-        headers = {}
-        if self.refresh_access_token_headers:
-            headers = self.refresh_access_token_headers
-        if self.refresh_access_token_authenticator:
-            refresh_auth_headers = self.refresh_access_token_authenticator.get_auth_header()
-            headers.update(refresh_auth_headers)
-        return headers