airbyte-cdk 0.72.0__py3-none-any.whl → 6.17.1.dev0__py3-none-any.whl

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

@@ -4,10 +4,11 @@
 
 from abc import abstractmethod
 from dataclasses import dataclass
-from typing import Any, List, Optional
+from typing import Any, Optional
 
 import requests
-from airbyte_cdk.sources.declarative.types import Record
+
+from airbyte_cdk.sources.types import Record
 
 
 @dataclass
@@ -24,20 +25,22 @@ class PaginationStrategy:
         """
 
     @abstractmethod
-    def next_page_token(self, response: requests.Response, last_records: List[Record]) -> Optional[Any]:
+    def next_page_token(
+        self,
+        response: requests.Response,
+        last_page_size: int,
+        last_record: Optional[Record],
+        last_page_token_value: Optional[Any],
+    ) -> Optional[Any]:
         """
         :param response: response to process
-        :param last_records: records extracted from the response
+        :param last_page_size: the number of records read from the response
+        :param last_record: the last record extracted from the response
+        :param last_page_token_value: The current value of the page token made on the last request
         :return: next page token. Returns None if there are no more pages to fetch
         """
         pass
 
-    @abstractmethod
-    def reset(self) -> None:
-        """
-        Reset the pagination's inner state
-        """
-
     @abstractmethod
     def get_page_size(self) -> Optional[int]:
         """

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

@@ -3,12 +3,16 @@
 #
 
 from abc import ABC, abstractmethod
-from typing import Any, List, Optional
+from typing import Any, Optional
 
 import requests
-from airbyte_cdk.sources.declarative.incremental import Cursor
-from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import PaginationStrategy
-from airbyte_cdk.sources.declarative.types import Record
+
+from airbyte_cdk.sources.declarative.incremental.declarative_cursor import DeclarativeCursor
+from airbyte_cdk.sources.declarative.requesters.paginators.strategies.pagination_strategy import (
+    PaginationStrategy,
+)
+from airbyte_cdk.sources.streams.concurrent.cursor import ConcurrentCursor
+from airbyte_cdk.sources.types import Record
 
 
 class PaginationStopCondition(ABC):
@@ -23,7 +27,11 @@ class PaginationStopCondition(ABC):
 
 
 class CursorStopCondition(PaginationStopCondition):
-    def __init__(self, cursor: Cursor):
+    def __init__(
+        self,
+        cursor: DeclarativeCursor
+        | ConcurrentCursor,  # migrate to use both old and concurrent versions
+    ):
         self._cursor = cursor
 
     def is_met(self, record: Record) -> bool:
@@ -35,15 +43,20 @@ class StopConditionPaginationStrategyDecorator(PaginationStrategy):
         self._delegate = _delegate
         self._stop_condition = stop_condition
 
-    def next_page_token(self, response: requests.Response, last_records: List[Record]) -> Optional[Any]:
-        # We evaluate in reverse order because the assumption is that most of the APIs using data feed structure will return records in
-        # descending order. In terms of performance/memory, we return the records lazily
-        if last_records and any(self._stop_condition.is_met(record) for record in reversed(last_records)):
+    def next_page_token(
+        self,
+        response: requests.Response,
+        last_page_size: int,
+        last_record: Optional[Record],
+        last_page_token_value: Optional[Any] = None,
+    ) -> Optional[Any]:
+        # We evaluate in reverse order because the assumption is that most of the APIs using data feed structure
+        # will return records in descending order. In terms of performance/memory, we return the records lazily
+        if last_record and self._stop_condition.is_met(last_record):
             return None
-        return self._delegate.next_page_token(response, last_records)
-
-    def reset(self) -> None:
-        self._delegate.reset()
+        return self._delegate.next_page_token(
+            response, last_page_size, last_record, last_page_token_value
+        )
 
     def get_page_size(self) -> Optional[int]:
         return self._delegate.get_page_size()

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

@@ -2,9 +2,22 @@
 # Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
+from airbyte_cdk.sources.declarative.requesters.request_options.datetime_based_request_options_provider import (
+    DatetimeBasedRequestOptionsProvider,
+)
+from airbyte_cdk.sources.declarative.requesters.request_options.default_request_options_provider import (
+    DefaultRequestOptionsProvider,
+)
 from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_request_options_provider import (
     InterpolatedRequestOptionsProvider,
 )
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
 
-__all__ = ["InterpolatedRequestOptionsProvider", "RequestOptionsProvider"]
+__all__ = [
+    "DatetimeBasedRequestOptionsProvider",
+    "DefaultRequestOptionsProvider",
+    "InterpolatedRequestOptionsProvider",
+    "RequestOptionsProvider",
+]

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

@@ -0,0 +1,91 @@
+#
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+#
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Mapping, MutableMapping, Optional, Union
+
+from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
+from airbyte_cdk.sources.declarative.requesters.request_option import (
+    RequestOption,
+    RequestOptionType,
+)
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
+from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
+
+
+@dataclass
+class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
+    """
+    Request options provider that extracts fields from the stream_slice and injects them into the respective location in the
+    outbound request being made
+    """
+
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+    start_time_option: Optional[RequestOption] = None
+    end_time_option: Optional[RequestOption] = None
+    partition_field_start: Optional[str] = None
+    partition_field_end: Optional[str] = None
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._partition_field_start = InterpolatedString.create(
+            self.partition_field_start or "start_time", parameters=parameters
+        )
+        self._partition_field_end = InterpolatedString.create(
+            self.partition_field_end or "end_time", parameters=parameters
+        )
+
+    def get_request_params(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Mapping[str, Any]:
+        return self._get_request_options(RequestOptionType.request_parameter, stream_slice)
+
+    def get_request_headers(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Mapping[str, Any]:
+        return self._get_request_options(RequestOptionType.header, stream_slice)
+
+    def get_request_body_data(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Union[Mapping[str, Any], str]:
+        return self._get_request_options(RequestOptionType.body_data, stream_slice)
+
+    def get_request_body_json(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Mapping[str, Any]:
+        return self._get_request_options(RequestOptionType.body_json, stream_slice)
+
+    def _get_request_options(
+        self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]
+    ) -> Mapping[str, Any]:
+        options: MutableMapping[str, Any] = {}
+        if not stream_slice:
+            return options
+        if self.start_time_option and self.start_time_option.inject_into == option_type:
+            options[self.start_time_option.field_name.eval(config=self.config)] = stream_slice.get(  # type: ignore # field_name is always casted to an interpolated string
+                self._partition_field_start.eval(self.config)
+            )
+        if self.end_time_option and self.end_time_option.inject_into == option_type:
+            options[self.end_time_option.field_name.eval(config=self.config)] = stream_slice.get(  # type: ignore [union-attr]
+                self._partition_field_end.eval(self.config)
+            )
+        return options

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

@@ -0,0 +1,60 @@
+#
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+#
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Mapping, Optional, Union
+
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
+from airbyte_cdk.sources.types import StreamSlice, StreamState
+
+
+@dataclass
+class DefaultRequestOptionsProvider(RequestOptionsProvider):
+    """
+    Request options provider that extracts fields from the stream_slice and injects them into the respective location in the
+    outbound request being made
+    """
+
+    parameters: InitVar[Mapping[str, Any]]
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        pass
+
+    def get_request_params(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Mapping[str, Any]:
+        return {}
+
+    def get_request_headers(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Mapping[str, Any]:
+        return {}
+
+    def get_request_body_data(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Union[Mapping[str, Any], str]:
+        return {}
+
+    def get_request_body_json(
+        self,
+        *,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+    ) -> Mapping[str, Any]:
+        return {}

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

@@ -5,9 +5,12 @@
 from dataclasses import InitVar, dataclass, field
 from typing import Any, Mapping, Optional, Union
 
-from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import InterpolatedNestedMapping, NestedMapping
+from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import (
+    InterpolatedNestedMapping,
+    NestedMapping,
+)
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.declarative.types import Config, StreamSlice, StreamState
+from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
 
 @dataclass
@@ -17,21 +20,31 @@ class InterpolatedNestedRequestInputProvider:
     """
 
     parameters: InitVar[Mapping[str, Any]]
-    request_inputs: Optional[NestedMapping] = field(default=None)
+    request_inputs: Optional[Union[str, NestedMapping]] = field(default=None)
     config: Config = field(default_factory=dict)
-    _interpolator: Union[InterpolatedString, InterpolatedNestedMapping] = field(init=False, repr=False, default=None)
-    _request_inputs: Union[str, Mapping[str, str]] = field(init=False, repr=False, default=None)
-
-    def __post_init__(self, parameters: Mapping[str, Any]):
-
+    _interpolator: Optional[Union[InterpolatedString, InterpolatedNestedMapping]] = field(
+        init=False, repr=False, default=None
+    )
+    _request_inputs: Optional[Union[str, NestedMapping]] = field(
+        init=False, repr=False, default=None
+    )
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._request_inputs = self.request_inputs or {}
-        if isinstance(self.request_inputs, str):
-            self._interpolator = InterpolatedString(self.request_inputs, default="", parameters=parameters)
+        if isinstance(self._request_inputs, str):
+            self._interpolator = InterpolatedString(
+                self._request_inputs, default="", parameters=parameters
+            )
         else:
-            self._interpolator = InterpolatedNestedMapping(self._request_inputs, parameters=parameters)
+            self._interpolator = InterpolatedNestedMapping(
+                self._request_inputs, parameters=parameters
+            )
 
     def eval_request_inputs(
-        self, stream_state: StreamState, stream_slice: Optional[StreamSlice] = None, next_page_token: Mapping[str, Any] = None
+        self,
+        stream_state: Optional[StreamState] = None,
+        stream_slice: Optional[StreamSlice] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, Any]:
         """
         Returns the request inputs to set on an outgoing HTTP request
@@ -41,5 +54,9 @@ class InterpolatedNestedRequestInputProvider:
         :param next_page_token: The pagination token
         :return: The request inputs to set on an outgoing HTTP request
         """
-        kwargs = {"stream_state": stream_state, "stream_slice": stream_slice, "next_page_token": next_page_token}
-        return self._interpolator.eval(self.config, **kwargs)
+        kwargs = {
+            "stream_state": stream_state,
+            "stream_slice": stream_slice,
+            "next_page_token": next_page_token,
+        }
+        return self._interpolator.eval(self.config, **kwargs)  # type: ignore  # self._interpolator is always initialized with a value and will not be None

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

@@ -7,7 +7,7 @@ from typing import Any, Mapping, Optional, Tuple, Type, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_mapping import InterpolatedMapping
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.declarative.types import Config, StreamSlice, StreamState
+from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
 
 @dataclass
@@ -19,24 +19,29 @@ class InterpolatedRequestInputProvider:
     parameters: InitVar[Mapping[str, Any]]
     request_inputs: Optional[Union[str, Mapping[str, str]]] = field(default=None)
     config: Config = field(default_factory=dict)
-    _interpolator: Union[InterpolatedString, InterpolatedMapping] = field(init=False, repr=False, default=None)
-    _request_inputs: Union[str, Mapping[str, str]] = field(init=False, repr=False, default=None)
-
-    def __post_init__(self, parameters: Mapping[str, Any]):
+    _interpolator: Optional[Union[InterpolatedString, InterpolatedMapping]] = field(
+        init=False, repr=False, default=None
+    )
+    _request_inputs: Optional[Union[str, Mapping[str, str]]] = field(
+        init=False, repr=False, default=None
+    )
 
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._request_inputs = self.request_inputs or {}
-        if isinstance(self.request_inputs, str):
-            self._interpolator = InterpolatedString(self.request_inputs, default="", parameters=parameters)
+        if isinstance(self._request_inputs, str):
+            self._interpolator = InterpolatedString(
+                self._request_inputs, default="", parameters=parameters
+            )
         else:
             self._interpolator = InterpolatedMapping(self._request_inputs, parameters=parameters)
 
     def eval_request_inputs(
         self,
-        stream_state: StreamState,
+        stream_state: Optional[StreamState] = None,
         stream_slice: Optional[StreamSlice] = None,
-        next_page_token: Mapping[str, Any] = None,
-        valid_key_types: Tuple[Type[Any]] = None,
-        valid_value_types: Tuple[Type[Any]] = None,
+        next_page_token: Optional[Mapping[str, Any]] = None,
+        valid_key_types: Optional[Tuple[Type[Any]]] = None,
+        valid_value_types: Optional[Tuple[Type[Any], ...]] = None,
     ) -> Mapping[str, Any]:
         """
         Returns the request inputs to set on an outgoing HTTP request
@@ -48,12 +53,19 @@ class InterpolatedRequestInputProvider:
         :param valid_value_types: A tuple of types that the interpolator should allow
         :return: The request inputs to set on an outgoing HTTP request
         """
-        kwargs = {"stream_state": stream_state, "stream_slice": stream_slice, "next_page_token": next_page_token}
-        interpolated_value = self._interpolator.eval(
-            self.config, valid_key_types=valid_key_types, valid_value_types=valid_value_types, **kwargs
+        kwargs = {
+            "stream_state": stream_state,
+            "stream_slice": stream_slice,
+            "next_page_token": next_page_token,
+        }
+        interpolated_value = self._interpolator.eval(  # type: ignore # self._interpolator is always initialized with a value and will not be None
+            self.config,
+            valid_key_types=valid_key_types,
+            valid_value_types=valid_value_types,
+            **kwargs,
         )
 
         if isinstance(interpolated_value, dict):
             non_null_tokens = {k: v for k, v in interpolated_value.items() if v is not None}
             return non_null_tokens
-        return interpolated_value
+        return interpolated_value  # type: ignore[no-any-return]

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

@@ -5,13 +5,20 @@
 from dataclasses import InitVar, dataclass, field
 from typing import Any, Mapping, MutableMapping, Optional, Union
 
+from typing_extensions import deprecated
+
 from airbyte_cdk.sources.declarative.interpolation.interpolated_nested_mapping import NestedMapping
 from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_nested_request_input_provider import (
     InterpolatedNestedRequestInputProvider,
 )
-from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_request_input_provider import InterpolatedRequestInputProvider
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
-from airbyte_cdk.sources.declarative.types import Config, StreamSlice, StreamState
+from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_request_input_provider import (
+    InterpolatedRequestInputProvider,
+)
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
+from airbyte_cdk.sources.source import ExperimentalClassWarning
+from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
 
 RequestInput = Union[str, Mapping[str, str]]
 ValidRequestTypes = (str, list)
@@ -37,7 +44,7 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
     request_body_data: Optional[RequestInput] = None
     request_body_json: Optional[NestedMapping] = None
 
-    def __post_init__(self, parameters: Mapping[str, Any]):
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         if self.request_parameters is None:
             self.request_parameters = {}
         if self.request_headers is None:
@@ -48,7 +55,9 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
             self.request_body_json = {}
 
         if self.request_body_json and self.request_body_data:
-            raise ValueError("RequestOptionsProvider should only contain either 'request_body_data' or 'request_body_json' not both")
+            raise ValueError(
+                "RequestOptionsProvider should only contain either 'request_body_data' or 'request_body_json' not both"
+            )
 
         self._parameter_interpolator = InterpolatedRequestInputProvider(
             config=self.config, request_inputs=self.request_parameters, parameters=parameters
@@ -71,7 +80,11 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> MutableMapping[str, Any]:
         interpolated_value = self._parameter_interpolator.eval_request_inputs(
-            stream_state, stream_slice, next_page_token, valid_key_types=(str,), valid_value_types=ValidRequestTypes
+            stream_state,
+            stream_slice,
+            next_page_token,
+            valid_key_types=(str,),
+            valid_value_types=ValidRequestTypes,
         )
         if isinstance(interpolated_value, dict):
             return interpolated_value
@@ -84,7 +97,9 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
     ) -> Mapping[str, Any]:
-        return self._headers_interpolator.eval_request_inputs(stream_state, stream_slice, next_page_token)
+        return self._headers_interpolator.eval_request_inputs(
+            stream_state, stream_slice, next_page_token
+        )
 
     def get_request_body_data(
         self,
@@ -92,7 +107,7 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         stream_state: Optional[StreamState] = None,
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
-    ) -> Optional[Union[Mapping, str]]:
+    ) -> Union[Mapping[str, Any], str]:
         return self._body_data_interpolator.eval_request_inputs(
             stream_state,
             stream_slice,
@@ -107,5 +122,43 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
         stream_state: Optional[StreamState] = None,
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
-    ) -> Optional[Mapping]:
-        return self._body_json_interpolator.eval_request_inputs(stream_state, stream_slice, next_page_token)
+    ) -> Mapping[str, Any]:
+        return self._body_json_interpolator.eval_request_inputs(
+            stream_state, stream_slice, next_page_token
+        )
+
+    @deprecated(
+        "This class is temporary and used to incrementally deliver low-code to concurrent",
+        category=ExperimentalClassWarning,
+    )
+    def request_options_contain_stream_state(self) -> bool:
+        """
+        Temporary helper method used as we move low-code streams to the concurrent framework. This method determines if
+        the InterpolatedRequestOptionsProvider has is a dependency on a non-thread safe interpolation context such as
+        stream_state.
+        """
+
+        return (
+            self._check_if_interpolation_uses_stream_state(self.request_parameters)
+            or self._check_if_interpolation_uses_stream_state(self.request_headers)
+            or self._check_if_interpolation_uses_stream_state(self.request_body_data)
+            or self._check_if_interpolation_uses_stream_state(self.request_body_json)
+        )
+
+    @staticmethod
+    def _check_if_interpolation_uses_stream_state(
+        request_input: Optional[Union[RequestInput, NestedMapping]],
+    ) -> bool:
+        if not request_input:
+            return False
+        elif isinstance(request_input, str):
+            return "stream_state" in request_input
+        else:
+            for key, val in request_input.items():
+                # Covers the case of RequestInput in the form of a string or Mapping[str, str]. It also covers the case
+                # of a NestedMapping where the value is a string.
+                # Note: Doesn't account for nested mappings for request_body_json, but I don't see stream_state used in that way
+                # in our code
+                if "stream_state" in key or (isinstance(val, str) and "stream_state" in val):
+                    return True
+        return False

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

@@ -6,7 +6,7 @@ from abc import abstractmethod
 from dataclasses import dataclass
 from typing import Any, Mapping, Optional, Union
 
-from airbyte_cdk.sources.declarative.types import StreamSlice, StreamState
+from airbyte_cdk.sources.types import StreamSlice, StreamState
 
 
 @dataclass

airbyte_cdk/sources/declarative/requesters/requester.py

@@ -7,10 +7,12 @@ from enum import Enum
 from typing import Any, Callable, Mapping, MutableMapping, Optional, Union
 
 import requests
+
 from airbyte_cdk.sources.declarative.auth.declarative_authenticator import DeclarativeAuthenticator
-from airbyte_cdk.sources.declarative.requesters.error_handlers.response_status import ResponseStatus
-from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import RequestOptionsProvider
-from airbyte_cdk.sources.declarative.types import StreamSlice, StreamState
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
+from airbyte_cdk.sources.types import StreamSlice, StreamState
 
 
 class HttpMethod(Enum):
@@ -18,7 +20,9 @@ class HttpMethod(Enum):
     Http Method to use when submitting an outgoing HTTP request
     """
 
+    DELETE = "DELETE"
     GET = "GET"
+    PATCH = "PATCH"
     POST = "POST"
 
 
@@ -68,18 +72,6 @@ class Requester(RequestOptionsProvider):
         E.g: you might want to define query parameters for paging if next_page_token is not None.
         """
 
-    @abstractmethod
-    def interpret_response_status(self, response: requests.Response) -> ResponseStatus:
-        """
-        Specifies conditions for backoff, error handling and reporting based on the response from the server.
-
-        By default, back off on the following HTTP response statuses:
-         - 429 (Too Many Requests) indicating rate limiting
-         - 500s to handle transient server errors
-
-        Unexpected but transient exceptions (connection timeout, DNS resolution failed, etc..) are retried by default.
-        """
-
     @abstractmethod
     def get_request_headers(
         self,
@@ -99,7 +91,7 @@ class Requester(RequestOptionsProvider):
         stream_state: Optional[StreamState] = None,
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
-    ) -> Optional[Mapping[str, Any]]:
+    ) -> Union[Mapping[str, Any], str]:
         """
         Specifies how to populate the body of the request with a non-JSON payload.
 
@@ -117,7 +109,7 @@ class Requester(RequestOptionsProvider):
         stream_state: Optional[StreamState] = None,
         stream_slice: Optional[StreamSlice] = None,
         next_page_token: Optional[Mapping[str, Any]] = None,
-    ) -> Optional[Mapping[str, Any]]:
+    ) -> Mapping[str, Any]:
         """
         Specifies how to populate the body of the request with a JSON payload.
 

airbyte_cdk/sources/declarative/resolvers/__init__.py

@@ -0,0 +1,41 @@
+#
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+#
+
+from typing import Mapping
+
+from pydantic.v1 import BaseModel
+
+from airbyte_cdk.sources.declarative.models import (
+    ConfigComponentsResolver as ConfigComponentsResolverModel,
+)
+from airbyte_cdk.sources.declarative.models import (
+    HttpComponentsResolver as HttpComponentsResolverModel,
+)
+from airbyte_cdk.sources.declarative.resolvers.components_resolver import (
+    ComponentMappingDefinition,
+    ComponentsResolver,
+    ResolvedComponentMappingDefinition,
+)
+from airbyte_cdk.sources.declarative.resolvers.config_components_resolver import (
+    ConfigComponentsResolver,
+    StreamConfig,
+)
+from airbyte_cdk.sources.declarative.resolvers.http_components_resolver import (
+    HttpComponentsResolver,
+)
+
+COMPONENTS_RESOLVER_TYPE_MAPPING: Mapping[str, type[BaseModel]] = {
+    "HttpComponentsResolver": HttpComponentsResolverModel,
+    "ConfigComponentsResolver": ConfigComponentsResolverModel,
+}
+
+__all__ = [
+    "ComponentsResolver",
+    "HttpComponentsResolver",
+    "ComponentMappingDefinition",
+    "ResolvedComponentMappingDefinition",
+    "StreamConfig",
+    "ConfigComponentsResolver",
+    "COMPONENTS_RESOLVER_TYPE_MAPPING",
+]