airbyte-cdk 6.13.1.dev4109__py3-none-any.whl → 6.14.0__py3-none-any.whl

airbyte_cdk/sources/declarative/retrievers/simple_retriever.py

@@ -6,7 +6,18 @@ import json
 from dataclasses import InitVar, dataclass, field
 from functools import partial
 from itertools import islice
-from typing import Any, Callable, Iterable, List, Mapping, Optional, Set, Tuple, Union
+from typing import (
+    Any,
+    Callable,
+    Iterable,
+    List,
+    Mapping,
+    MutableMapping,
+    Optional,
+    Set,
+    Tuple,
+    Union,
+)
 
 import requests
 
@@ -79,6 +90,9 @@ class SimpleRetriever(Retriever):
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._paginator = self.paginator or NoPagination(parameters=parameters)
+        self._last_response: Optional[requests.Response] = None
+        self._last_page_size: int = 0
+        self._last_record: Optional[Record] = None
         self._parameters = parameters
         self._name = (
             InterpolatedString(self._name, parameters=parameters)
@@ -86,6 +100,10 @@ class SimpleRetriever(Retriever):
             else self._name
         )
 
+        # This mapping is used during a resumable full refresh syncs to indicate whether a partition has started syncing
+        # records. Partitions serve as the key and map to True if they already began processing records
+        self._partition_started: MutableMapping[Any, bool] = dict()
+
     @property  # type: ignore
     def name(self) -> str:
         """
@@ -233,13 +251,17 @@ class SimpleRetriever(Retriever):
             raise ValueError("Request body json cannot be a string")
         return body_json
 
-    def _paginator_path(self, next_page_token: Optional[Mapping[str, Any]] = None) -> Optional[str]:
+    def _paginator_path(
+        self,
+    ) -> Optional[str]:
         """
         If the paginator points to a path, follow it, else return nothing so the requester is used.
+        :param stream_state:
+        :param stream_slice:
         :param next_page_token:
         :return:
         """
-        return self._paginator.path(next_page_token=next_page_token)
+        return self._paginator.path()
 
     def _parse_response(
         self,
@@ -250,15 +272,22 @@ class SimpleRetriever(Retriever):
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Iterable[Record]:
         if not response:
+            self._last_response = None
             yield from []
         else:
-            yield from self.record_selector.select_records(
+            self._last_response = response
+            record_generator = self.record_selector.select_records(
                 response=response,
                 stream_state=stream_state,
                 records_schema=records_schema,
                 stream_slice=stream_slice,
                 next_page_token=next_page_token,
             )
+            self._last_page_size = 0
+            for record in record_generator:
+                self._last_page_size += 1
+                self._last_record = record
+                yield record
 
     @property  # type: ignore
     def primary_key(self) -> Optional[Union[str, List[str], List[List[str]]]]:
@@ -270,13 +299,7 @@ class SimpleRetriever(Retriever):
         if not isinstance(value, property):
             self._primary_key = value
 
-    def _next_page_token(
-        self,
-        response: requests.Response,
-        last_page_size: int,
-        last_record: Optional[Record],
-        last_page_token_value: Optional[Any],
-    ) -> Optional[Mapping[str, Any]]:
+    def _next_page_token(self, response: requests.Response) -> Optional[Mapping[str, Any]]:
         """
         Specifies a pagination strategy.
 
@@ -284,12 +307,7 @@ class SimpleRetriever(Retriever):
 
         :return: The token for the next page from the input response object. Returning None means there are no more pages to read in this response.
         """
-        return self._paginator.next_page_token(
-            response=response,
-            last_page_size=last_page_size,
-            last_record=last_record,
-            last_page_token_value=last_page_token_value,
-        )
+        return self._paginator.next_page_token(response, self._last_page_size, self._last_record)
 
     def _fetch_next_page(
         self,
@@ -298,7 +316,7 @@ class SimpleRetriever(Retriever):
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Optional[requests.Response]:
         return self.requester.send_request(
-            path=self._paginator_path(next_page_token=next_page_token),
+            path=self._paginator_path(),
             stream_state=stream_state,
             stream_slice=stream_slice,
             next_page_token=next_page_token,
@@ -327,37 +345,20 @@ class SimpleRetriever(Retriever):
     # This logic is similar to _read_pages in the HttpStream class. When making changes here, consider making changes there as well.
     def _read_pages(
         self,
-        records_generator_fn: Callable[[Optional[requests.Response]], Iterable[Record]],
+        records_generator_fn: Callable[[Optional[requests.Response]], Iterable[StreamData]],
         stream_state: Mapping[str, Any],
         stream_slice: StreamSlice,
-    ) -> Iterable[Record]:
+    ) -> Iterable[StreamData]:
         pagination_complete = False
-        initial_token = self._paginator.get_initial_token()
-        next_page_token: Optional[Mapping[str, Any]] = (
-            {"next_page_token": initial_token} if initial_token else None
-        )
+        next_page_token = None
         while not pagination_complete:
             response = self._fetch_next_page(stream_state, stream_slice, next_page_token)
-
-            last_page_size = 0
-            last_record: Optional[Record] = None
-            for record in records_generator_fn(response):
-                last_page_size += 1
-                last_record = record
-                yield record
+            yield from records_generator_fn(response)
 
             if not response:
                 pagination_complete = True
             else:
-                last_page_token_value = (
-                    next_page_token.get("next_page_token") if next_page_token else None
-                )
-                next_page_token = self._next_page_token(
-                    response=response,
-                    last_page_size=last_page_size,
-                    last_record=last_record,
-                    last_page_token_value=last_page_token_value,
-                )
+                next_page_token = self._next_page_token(response)
                 if not next_page_token:
                     pagination_complete = True
 
@@ -366,38 +367,19 @@ class SimpleRetriever(Retriever):
 
     def _read_single_page(
         self,
-        records_generator_fn: Callable[[Optional[requests.Response]], Iterable[Record]],
+        records_generator_fn: Callable[[Optional[requests.Response]], Iterable[StreamData]],
         stream_state: Mapping[str, Any],
         stream_slice: StreamSlice,
     ) -> Iterable[StreamData]:
-        initial_token = stream_state.get("next_page_token")
-        if initial_token is None:
-            initial_token = self._paginator.get_initial_token()
-        next_page_token: Optional[Mapping[str, Any]] = (
-            {"next_page_token": initial_token} if initial_token else None
-        )
-
-        response = self._fetch_next_page(stream_state, stream_slice, next_page_token)
-
-        last_page_size = 0
-        last_record: Optional[Record] = None
-        for record in records_generator_fn(response):
-            last_page_size += 1
-            last_record = record
-            yield record
+        response = self._fetch_next_page(stream_state, stream_slice)
+        yield from records_generator_fn(response)
 
         if not response:
-            next_page_token = {FULL_REFRESH_SYNC_COMPLETE_KEY: True}
+            next_page_token: Mapping[str, Any] = {FULL_REFRESH_SYNC_COMPLETE_KEY: True}
         else:
-            last_page_token_value = (
-                next_page_token.get("next_page_token") if next_page_token else None
-            )
-            next_page_token = self._next_page_token(
-                response=response,
-                last_page_size=last_page_size,
-                last_record=last_record,
-                last_page_token_value=last_page_token_value,
-            ) or {FULL_REFRESH_SYNC_COMPLETE_KEY: True}
+            next_page_token = self._next_page_token(response) or {
+                FULL_REFRESH_SYNC_COMPLETE_KEY: True
+            }
 
         if self.cursor:
             self.cursor.close_slice(
@@ -432,14 +414,25 @@ class SimpleRetriever(Retriever):
         if self.cursor and isinstance(self.cursor, ResumableFullRefreshCursor):
             stream_state = self.state
 
-            # Before syncing the RFR stream, we check if the job's prior attempt was successful and don't need to
-            # fetch more records. The platform deletes stream state for full refresh streams before starting a
-            # new job, so we don't need to worry about this value existing for the initial attempt
+            # Before syncing the RFR stream, we check if the job's prior attempt was successful and don't need to fetch more records
+            # The platform deletes stream state for full refresh streams before starting a new job, so we don't need to worry about
+            # this value existing for the initial attempt
             if stream_state.get(FULL_REFRESH_SYNC_COMPLETE_KEY):
                 return
+            cursor_value = stream_state.get("next_page_token")
+
+            # The first attempt to read a page for the current partition should reset the paginator to the current
+            # cursor state which is initially assigned to the incoming state from the platform
+            partition_key = self._to_partition_key(_slice.partition)
+            if partition_key not in self._partition_started:
+                self._partition_started[partition_key] = True
+                self._paginator.reset(reset_value=cursor_value)
 
             yield from self._read_single_page(record_generator, stream_state, _slice)
         else:
+            # Fixing paginator types has a long tail of dependencies
+            self._paginator.reset()
+
             for stream_data in self._read_pages(record_generator, self.state, _slice):
                 current_record = self._extract_record(stream_data, _slice)
                 if self.cursor and current_record:
@@ -525,7 +518,7 @@ class SimpleRetriever(Retriever):
         stream_state: Mapping[str, Any],
         records_schema: Mapping[str, Any],
         stream_slice: Optional[StreamSlice],
-    ) -> Iterable[Record]:
+    ) -> Iterable[StreamData]:
         yield from self._parse_response(
             response,
             stream_slice=stream_slice,
@@ -569,7 +562,7 @@ class SimpleRetrieverTestReadDecorator(SimpleRetriever):
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Optional[requests.Response]:
         return self.requester.send_request(
-            path=self._paginator_path(next_page_token=next_page_token),
+            path=self._paginator_path(),
             stream_state=stream_state,
             stream_slice=stream_slice,
             next_page_token=next_page_token,

airbyte_cdk/sources/declarative/stream_slicers/declarative_partition_generator.py

@@ -1,6 +1,6 @@
 # Copyright (c) 2024 Airbyte, Inc., all rights reserved.
 
-from typing import Any, Iterable, Mapping, Optional
+from typing import Any, Callable, Iterable, Mapping, Optional
 
 from airbyte_cdk.sources.declarative.retrievers import Retriever
 from airbyte_cdk.sources.message import MessageRepository
@@ -16,7 +16,7 @@ class DeclarativePartitionFactory:
         self,
         stream_name: str,
         json_schema: Mapping[str, Any],
-        retriever: Retriever,
+        retriever_factory: Callable[[], Retriever],
         message_repository: MessageRepository,
     ) -> None:
         """
@@ -26,14 +26,14 @@ class DeclarativePartitionFactory:
         """
         self._stream_name = stream_name
         self._json_schema = json_schema
-        self._retriever = retriever
+        self._retriever_factory = retriever_factory
         self._message_repository = message_repository
 
     def create(self, stream_slice: StreamSlice) -> Partition:
         return DeclarativePartition(
             self._stream_name,
             self._json_schema,
-            self._retriever,
+            self._retriever_factory(),
             self._message_repository,
             stream_slice,
         )

airbyte_cdk/sources/declarative/transformations/flatten_fields.py

@@ -11,8 +11,6 @@ from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
 @dataclass
 class FlattenFields(RecordTransformation):
-    flatten_lists: bool = True
-
     def transform(
         self,
         record: Dict[str, Any],
@@ -41,7 +39,7 @@ class FlattenFields(RecordTransformation):
                     )
                     stack.append((value, new_key))
 
-            elif isinstance(current_record, list) and self.flatten_lists:
+            elif isinstance(current_record, list):
                 for i, item in enumerate(current_record):
                     force_with_parent_name = True
                     stack.append((item, f"{parent_key}.{i}"))

airbyte_cdk/sources/file_based/config/abstract_file_based_spec.py

@@ -31,17 +31,6 @@ class DeliverRawFiles(BaseModel):
 
     delivery_type: Literal["use_file_transfer"] = Field("use_file_transfer", const=True)
 
-    preserve_directory_structure: bool = Field(
-        title="Preserve Sub-Directories in File Paths",
-        description=(
-            "If enabled, sends subdirectory folder structure "
-            "along with source file names to the destination. "
-            "Otherwise, files will be synced by their names only. "
-            "This option is ignored when file-based replication is not enabled."
-        ),
-        default=True,
-    )
-
 
 class AbstractFileBasedSpec(BaseModel):
     """

airbyte_cdk/sources/file_based/exceptions.py

@@ -111,40 +111,6 @@ class ErrorListingFiles(BaseFileBasedSourceError):
     pass
 
 
-class DuplicatedFilesError(BaseFileBasedSourceError):
-    def __init__(self, duplicated_files_names: List[dict[str, List[str]]], **kwargs: Any):
-        self._duplicated_files_names = duplicated_files_names
-        self._stream_name: str = kwargs["stream"]
-        super().__init__(self._format_duplicate_files_error_message(), **kwargs)
-
-    def _format_duplicate_files_error_message(self) -> str:
-        duplicated_files_messages = []
-        for duplicated_file in self._duplicated_files_names:
-            for duplicated_file_name, file_paths in duplicated_file.items():
-                file_duplicated_message = (
-                    f"{len(file_paths)} duplicates found for file name {duplicated_file_name}:\n\n"
-                    + "".join(f"\n - {file_paths}")
-                )
-                duplicated_files_messages.append(file_duplicated_message)
-
-        error_message = (
-            f"ERROR: Duplicate filenames found for stream {self._stream_name}. "
-            "Duplicate file names are not allowed if the Preserve Sub-Directories in File Paths option is disabled. "
-            "Please remove or rename the duplicate files before attempting to re-run the sync.\n\n"
-            + "\n".join(duplicated_files_messages)
-        )
-
-        return error_message
-
-    def __repr__(self) -> str:
-        """Return a string representation of the exception."""
-        class_name = self.__class__.__name__
-        properties_str = ", ".join(
-            f"{k}={v!r}" for k, v in self.__dict__.items() if not k.startswith("_")
-        )
-        return f"{class_name}({properties_str})"
-
-
 class CustomFileBasedException(AirbyteTracedException):
     """
     A specialized exception for file-based connectors.

airbyte_cdk/sources/file_based/file_based_source.py

@@ -242,7 +242,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                         stream=self._make_default_stream(
                             stream_config=stream_config,
                             cursor=cursor,
-                            parsed_config=parsed_config,
+                            use_file_transfer=self._use_file_transfer(parsed_config),
                         ),
                         source=self,
                         logger=self.logger,
@@ -273,7 +273,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                         stream=self._make_default_stream(
                             stream_config=stream_config,
                             cursor=cursor,
-                            parsed_config=parsed_config,
+                            use_file_transfer=self._use_file_transfer(parsed_config),
                         ),
                         source=self,
                         logger=self.logger,
@@ -285,7 +285,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
                     stream = self._make_default_stream(
                         stream_config=stream_config,
                         cursor=cursor,
-                        parsed_config=parsed_config,
+                        use_file_transfer=self._use_file_transfer(parsed_config),
                     )
 
                 streams.append(stream)
@@ -298,7 +298,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
         self,
         stream_config: FileBasedStreamConfig,
         cursor: Optional[AbstractFileBasedCursor],
-        parsed_config: AbstractFileBasedSpec,
+        use_file_transfer: bool = False,
     ) -> AbstractFileBasedStream:
         return DefaultFileBasedStream(
             config=stream_config,
@@ -310,8 +310,7 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
             validation_policy=self._validate_and_get_validation_policy(stream_config),
             errors_collector=self.errors_collector,
             cursor=cursor,
-            use_file_transfer=self._use_file_transfer(parsed_config),
-            preserve_directory_structure=self._preserve_directory_structure(parsed_config),
+            use_file_transfer=use_file_transfer,
         )
 
     def _get_stream_from_catalog(
@@ -386,25 +385,3 @@ class FileBasedSource(ConcurrentSourceAdapter, ABC):
             and parsed_config.delivery_method.delivery_type == "use_file_transfer"
         )
         return use_file_transfer
-
-    @staticmethod
-    def _preserve_directory_structure(parsed_config: AbstractFileBasedSpec) -> bool:
-        """
-        Determines whether to preserve directory structure during file transfer.
-
-        When enabled, files maintain their subdirectory paths in the destination.
-        When disabled, files are flattened to the root of the destination.
-
-        Args:
-            parsed_config: The parsed configuration containing delivery method settings
-
-        Returns:
-            True if directory structure should be preserved (default), False otherwise
-        """
-        if (
-            FileBasedSource._use_file_transfer(parsed_config)
-            and hasattr(parsed_config.delivery_method, "preserve_directory_structure")
-            and parsed_config.delivery_method.preserve_directory_structure is not None
-        ):
-            return parsed_config.delivery_method.preserve_directory_structure
-        return True

airbyte_cdk/sources/file_based/file_based_stream_reader.py

@@ -135,17 +135,6 @@ class AbstractFileBasedStreamReader(ABC):
             return use_file_transfer
         return False
 
-    def preserve_directory_structure(self) -> bool:
-        # fall back to preserve subdirectories if config is not present or incomplete
-        if (
-            self.use_file_transfer()
-            and self.config
-            and hasattr(self.config.delivery_method, "preserve_directory_structure")
-            and self.config.delivery_method.preserve_directory_structure is not None
-        ):
-            return self.config.delivery_method.preserve_directory_structure
-        return True
-
     @abstractmethod
     def get_file(
         self, file: RemoteFile, local_directory: str, logger: logging.Logger
@@ -170,13 +159,10 @@ class AbstractFileBasedStreamReader(ABC):
         """
         ...
 
-    def _get_file_transfer_paths(self, file: RemoteFile, local_directory: str) -> List[str]:
-        preserve_directory_structure = self.preserve_directory_structure()
-        if preserve_directory_structure:
-            # Remove left slashes from source path format to make relative path for writing locally
-            file_relative_path = file.uri.lstrip("/")
-        else:
-            file_relative_path = path.basename(file.uri)
+    @staticmethod
+    def _get_file_transfer_paths(file: RemoteFile, local_directory: str) -> List[str]:
+        # Remove left slashes from source path format to make relative path for writing locally
+        file_relative_path = file.uri.lstrip("/")
         local_file_path = path.join(local_directory, file_relative_path)
 
         # Ensure the local directory exists

airbyte_cdk/sources/file_based/file_types/unstructured_parser.py

@@ -2,7 +2,6 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 import logging
-import os
 import traceback
 from datetime import datetime
 from io import BytesIO, IOBase
@@ -43,34 +42,12 @@ unstructured_partition_pdf = None
 unstructured_partition_docx = None
 unstructured_partition_pptx = None
 
-AIRBYTE_NLTK_DATA_DIR = "/airbyte/nltk_data"
-TMP_NLTK_DATA_DIR = "/tmp/nltk_data"
-
-
-def get_nltk_temp_folder() -> str:
-    """
-    For non-root connectors /tmp is not currently writable, but we should allow it in the future.
-    It's safe to use /airbyte for now. Fallback to /tmp for local development.
-    """
-    try:
-        nltk_data_dir = AIRBYTE_NLTK_DATA_DIR
-        os.makedirs(nltk_data_dir, exist_ok=True)
-    except OSError:
-        nltk_data_dir = TMP_NLTK_DATA_DIR
-        os.makedirs(nltk_data_dir, exist_ok=True)
-    return nltk_data_dir
-
-
 try:
-    nltk_data_dir = get_nltk_temp_folder()
-    nltk.data.path.append(nltk_data_dir)
     nltk.data.find("tokenizers/punkt.zip")
     nltk.data.find("tokenizers/punkt_tab.zip")
-    nltk.data.find("tokenizers/averaged_perceptron_tagger_eng.zip")
 except LookupError:
-    nltk.download("punkt", download_dir=nltk_data_dir, quiet=True)
-    nltk.download("punkt_tab", download_dir=nltk_data_dir, quiet=True)
-    nltk.download("averaged_perceptron_tagger_eng", download_dir=nltk_data_dir, quiet=True)
+    nltk.download("punkt")
+    nltk.download("punkt_tab")
 
 
 def optional_decode(contents: Union[str, bytes]) -> str:

airbyte_cdk/sources/file_based/stream/default_file_based_stream.py

@@ -5,17 +5,14 @@
 import asyncio
 import itertools
 import traceback
-from collections import defaultdict
 from copy import deepcopy
 from functools import cache
-from os import path
-from typing import Any, Dict, Iterable, List, Mapping, MutableMapping, Optional, Set, Tuple, Union
+from typing import Any, Dict, Iterable, List, Mapping, MutableMapping, Optional, Set, Union
 
 from airbyte_cdk.models import AirbyteLogMessage, AirbyteMessage, FailureType, Level
 from airbyte_cdk.models import Type as MessageType
 from airbyte_cdk.sources.file_based.config.file_based_stream_config import PrimaryKeyType
 from airbyte_cdk.sources.file_based.exceptions import (
-    DuplicatedFilesError,
     FileBasedSourceError,
     InvalidSchemaError,
     MissingSchemaError,
@@ -46,8 +43,6 @@ class DefaultFileBasedStream(AbstractFileBasedStream, IncrementalMixin):
     """
 
     FILE_TRANSFER_KW = "use_file_transfer"
-    PRESERVE_DIRECTORY_STRUCTURE_KW = "preserve_directory_structure"
-    FILES_KEY = "files"
     DATE_TIME_FORMAT = "%Y-%m-%dT%H:%M:%S.%fZ"
     ab_last_mod_col = "_ab_source_file_last_modified"
     ab_file_name_col = "_ab_source_file_url"
@@ -55,15 +50,10 @@ class DefaultFileBasedStream(AbstractFileBasedStream, IncrementalMixin):
     source_file_url = "source_file_url"
     airbyte_columns = [ab_last_mod_col, ab_file_name_col]
     use_file_transfer = False
-    preserve_directory_structure = True
 
     def __init__(self, **kwargs: Any):
         if self.FILE_TRANSFER_KW in kwargs:
             self.use_file_transfer = kwargs.pop(self.FILE_TRANSFER_KW, False)
-        if self.PRESERVE_DIRECTORY_STRUCTURE_KW in kwargs:
-            self.preserve_directory_structure = kwargs.pop(
-                self.PRESERVE_DIRECTORY_STRUCTURE_KW, True
-            )
         super().__init__(**kwargs)
 
     @property
@@ -108,33 +98,15 @@ class DefaultFileBasedStream(AbstractFileBasedStream, IncrementalMixin):
         else:
             return super()._filter_schema_invalid_properties(configured_catalog_json_schema)
 
-    def _duplicated_files_names(
-        self, slices: List[dict[str, List[RemoteFile]]]
-    ) -> List[dict[str, List[str]]]:
-        seen_file_names: Dict[str, List[str]] = defaultdict(list)
-        for file_slice in slices:
-            for file_found in file_slice[self.FILES_KEY]:
-                file_name = path.basename(file_found.uri)
-                seen_file_names[file_name].append(file_found.uri)
-        return [
-            {file_name: paths} for file_name, paths in seen_file_names.items() if len(paths) > 1
-        ]
-
     def compute_slices(self) -> Iterable[Optional[Mapping[str, Any]]]:
         # Sort files by last_modified, uri and return them grouped by last_modified
         all_files = self.list_files()
         files_to_read = self._cursor.get_files_to_sync(all_files, self.logger)
         sorted_files_to_read = sorted(files_to_read, key=lambda f: (f.last_modified, f.uri))
         slices = [
-            {self.FILES_KEY: list(group[1])}
+            {"files": list(group[1])}
             for group in itertools.groupby(sorted_files_to_read, lambda f: f.last_modified)
         ]
-        if slices and not self.preserve_directory_structure:
-            duplicated_files_names = self._duplicated_files_names(slices)
-            if duplicated_files_names:
-                raise DuplicatedFilesError(
-                    stream=self.name, duplicated_files_names=duplicated_files_names
-                )
         return slices
 
     def transform_record(

airbyte_cdk/sources/streams/http/requests_native_auth/abstract_oauth.py

@@ -81,10 +81,10 @@ class AbstractOauth2Authenticator(AuthBase):
         Override to define additional parameters
         """
         payload: MutableMapping[str, Any] = {
-            self.get_grant_type_name(): self.get_grant_type(),
-            self.get_client_id_name(): self.get_client_id(),
-            self.get_client_secret_name(): self.get_client_secret(),
-            self.get_refresh_token_name(): self.get_refresh_token(),
+            "grant_type": self.get_grant_type(),
+            "client_id": self.get_client_id(),
+            "client_secret": self.get_client_secret(),
+            "refresh_token": self.get_refresh_token(),
         }
 
         if self.get_scopes():
@@ -206,26 +206,14 @@ class AbstractOauth2Authenticator(AuthBase):
     def get_token_refresh_endpoint(self) -> Optional[str]:
         """Returns the endpoint to refresh the access token"""
 
-    @abstractmethod
-    def get_client_id_name(self) -> str:
-        """The client id name to authenticate"""
-
     @abstractmethod
     def get_client_id(self) -> str:
         """The client id to authenticate"""
 
-    @abstractmethod
-    def get_client_secret_name(self) -> str:
-        """The client secret name to authenticate"""
-
     @abstractmethod
     def get_client_secret(self) -> str:
         """The client secret to authenticate"""
 
-    @abstractmethod
-    def get_refresh_token_name(self) -> str:
-        """The refresh token name to authenticate"""
-
     @abstractmethod
     def get_refresh_token(self) -> Optional[str]:
         """The token used to refresh the access token when it expires"""
@@ -258,10 +246,6 @@ class AbstractOauth2Authenticator(AuthBase):
     def get_grant_type(self) -> str:
         """Returns grant_type specified for requesting access_token"""
 
-    @abstractmethod
-    def get_grant_type_name(self) -> str:
-        """Returns grant_type specified name for requesting access_token"""
-
     @property
     @abstractmethod
     def access_token(self) -> str: