airbyte-cdk 6.33.0__py3-none-any.whl → 6.33.0.dev0__py3-none-any.whl

airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -112,6 +112,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     AddFields as AddFieldsModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    APIBudget as APIBudgetModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ApiKeyAuthenticator as ApiKeyAuthenticatorModel,
 )
@@ -226,6 +229,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ExponentialBackoffStrategy as ExponentialBackoffStrategyModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    FixedWindowCallRatePolicy as FixedWindowCallRatePolicyModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     FlattenFields as FlattenFieldsModel,
 )
@@ -235,12 +241,18 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     GzipParser as GzipParserModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    HTTPAPIBudget as HTTPAPIBudgetModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     HttpComponentsResolver as HttpComponentsResolverModel,
 )
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     HttpRequester as HttpRequesterModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    HttpRequestMatcher as HttpRequestMatcherModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     HttpResponseFilter as HttpResponseFilterModel,
 )
@@ -295,6 +307,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     MinMaxDatetime as MinMaxDatetimeModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    MovingWindowCallRatePolicy as MovingWindowCallRatePolicyModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     NoAuth as NoAuthModel,
 )
@@ -313,6 +328,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ParentStreamConfig as ParentStreamConfigModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    Rate as RateModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     RecordFilter as RecordFilterModel,
 )
@@ -356,6 +374,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     TypesMap as TypesMapModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    UnlimitedCallRatePolicy as UnlimitedCallRatePolicyModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import ValueType
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     WaitTimeFromHeader as WaitTimeFromHeaderModel,
@@ -469,6 +490,15 @@ from airbyte_cdk.sources.message import (
     MessageRepository,
     NoopMessageRepository,
 )
+from airbyte_cdk.sources.streams.call_rate import (
+    APIBudget,
+    FixedWindowCallRatePolicy,
+    HttpAPIBudget,
+    HttpRequestMatcher,
+    MovingWindowCallRatePolicy,
+    Rate,
+    UnlimitedCallRatePolicy,
+)
 from airbyte_cdk.sources.streams.concurrent.clamping import (
     ClampingEndProvider,
     ClampingStrategy,
@@ -520,6 +550,7 @@ class ModelToComponentFactory:
             self._evaluate_log_level(emit_connector_builder_messages)
         )
         self._connector_state_manager = connector_state_manager or ConnectorStateManager()
+        self._api_budget: Optional[Union[APIBudget, HttpAPIBudget]] = None
 
     def _init_mappings(self) -> None:
         self.PYDANTIC_MODEL_TO_CONSTRUCTOR: Mapping[Type[BaseModel], Callable[..., Any]] = {
@@ -607,6 +638,13 @@ class ModelToComponentFactory:
             StreamConfigModel: self.create_stream_config,
             ComponentMappingDefinitionModel: self.create_components_mapping_definition,
             ZipfileDecoderModel: self.create_zipfile_decoder,
+            APIBudgetModel: self.create_api_budget,
+            HTTPAPIBudgetModel: self.create_http_api_budget,
+            FixedWindowCallRatePolicyModel: self.create_fixed_window_call_rate_policy,
+            MovingWindowCallRatePolicyModel: self.create_moving_window_call_rate_policy,
+            UnlimitedCallRatePolicyModel: self.create_unlimited_call_rate_policy,
+            RateModel: self.create_rate,
+            HttpRequestMatcherModel: self.create_http_request_matcher,
         }
 
         # Needed for the case where we need to perform a second parse on the fields of a custom component
@@ -733,8 +771,8 @@ class ModelToComponentFactory:
         }
         return names_to_types[value_type]
 
+    @staticmethod
     def create_api_key_authenticator(
-        self,
         model: ApiKeyAuthenticatorModel,
         config: Config,
         token_provider: Optional[TokenProvider] = None,
@@ -756,8 +794,10 @@ class ModelToComponentFactory:
             )
 
         request_option = (
-            self._create_component_from_model(
-                model.inject_into, config, parameters=model.parameters or {}
+            RequestOption(
+                inject_into=RequestOptionType(model.inject_into.inject_into.value),
+                field_name=model.inject_into.field_name,
+                parameters=model.parameters or {},
             )
             if model.inject_into
             else RequestOption(
@@ -766,7 +806,6 @@ class ModelToComponentFactory:
                 parameters=model.parameters or {},
             )
         )
-
         return ApiKeyAuthenticator(
             token_provider=(
                 token_provider
@@ -848,7 +887,7 @@ class ModelToComponentFactory:
                 token_provider=token_provider,
             )
         else:
-            return self.create_api_key_authenticator(
+            return ModelToComponentFactory.create_api_key_authenticator(
                 ApiKeyAuthenticatorModel(
                     type="ApiKeyAuthenticator",
                     api_token="",
@@ -1488,15 +1527,19 @@ class ModelToComponentFactory:
             )
 
         end_time_option = (
-            self._create_component_from_model(
-                model.end_time_option, config, parameters=model.parameters or {}
+            RequestOption(
+                inject_into=RequestOptionType(model.end_time_option.inject_into.value),
+                field_name=model.end_time_option.field_name,
+                parameters=model.parameters or {},
             )
             if model.end_time_option
             else None
         )
         start_time_option = (
-            self._create_component_from_model(
-                model.start_time_option, config, parameters=model.parameters or {}
+            RequestOption(
+                inject_into=RequestOptionType(model.start_time_option.inject_into.value),
+                field_name=model.start_time_option.field_name,
+                parameters=model.parameters or {},
             )
             if model.start_time_option
             else None
@@ -1567,15 +1610,19 @@ class ModelToComponentFactory:
             cursor_model = model.incremental_sync
 
             end_time_option = (
-                self._create_component_from_model(
-                    cursor_model.end_time_option, config, parameters=cursor_model.parameters or {}
+                RequestOption(
+                    inject_into=RequestOptionType(cursor_model.end_time_option.inject_into.value),
+                    field_name=cursor_model.end_time_option.field_name,
+                    parameters=cursor_model.parameters or {},
                 )
                 if cursor_model.end_time_option
                 else None
             )
             start_time_option = (
-                self._create_component_from_model(
-                    cursor_model.start_time_option, config, parameters=cursor_model.parameters or {}
+                RequestOption(
+                    inject_into=RequestOptionType(cursor_model.start_time_option.inject_into.value),
+                    field_name=cursor_model.start_time_option.field_name,
+                    parameters=cursor_model.parameters or {},
                 )
                 if cursor_model.start_time_option
                 else None
@@ -1902,6 +1949,8 @@ class ModelToComponentFactory:
             )
         )
 
+        api_budget = self._api_budget
+
         request_options_provider = InterpolatedRequestOptionsProvider(
             request_body_data=model.request_body_data,
             request_body_json=model.request_body_json,
@@ -1922,6 +1971,7 @@ class ModelToComponentFactory:
             path=model.path,
             authenticator=authenticator,
             error_handler=error_handler,
+            api_budget=api_budget,
             http_method=HttpMethod[model.http_method.value],
             request_options_provider=request_options_provider,
             config=config,
@@ -2141,11 +2191,16 @@ class ModelToComponentFactory:
             additional_jwt_payload=model.additional_jwt_payload,
         )
 
+    @staticmethod
     def create_list_partition_router(
-        self, model: ListPartitionRouterModel, config: Config, **kwargs: Any
+        model: ListPartitionRouterModel, config: Config, **kwargs: Any
     ) -> ListPartitionRouter:
         request_option = (
-            self._create_component_from_model(model.request_option, config)
+            RequestOption(
+                inject_into=RequestOptionType(model.request_option.inject_into.value),
+                field_name=model.request_option.field_name,
+                parameters=model.parameters or {},
+            )
             if model.request_option
             else None
         )
@@ -2341,25 +2396,7 @@ class ModelToComponentFactory:
         model: RequestOptionModel, config: Config, **kwargs: Any
     ) -> RequestOption:
         inject_into = RequestOptionType(model.inject_into.value)
-        field_path: Optional[List[Union[InterpolatedString, str]]] = (
-            [
-                InterpolatedString.create(segment, parameters=kwargs.get("parameters", {}))
-                for segment in model.field_path
-            ]
-            if model.field_path
-            else None
-        )
-        field_name = (
-            InterpolatedString.create(model.field_name, parameters=kwargs.get("parameters", {}))
-            if model.field_name
-            else None
-        )
-        return RequestOption(
-            field_name=field_name,
-            field_path=field_path,
-            inject_into=inject_into,
-            parameters=kwargs.get("parameters", {}),
-        )
+        return RequestOption(field_name=model.field_name, inject_into=inject_into, parameters={})
 
     def create_record_selector(
         self,
@@ -2923,3 +2960,103 @@ class ModelToComponentFactory:
             return isinstance(parser.inner_parser, JsonParser)
         else:
             return False
+
+    def create_api_budget(self, model: APIBudgetModel, config: Config, **kwargs: Any) -> APIBudget:
+        policies = [
+            self._create_component_from_model(model=policy, config=config)
+            for policy in model.policies
+        ]
+
+        return APIBudget(
+            policies=policies,
+            maximum_attempts_to_acquire=model.maximum_attempts_to_acquire or 100000,
+        )
+
+    def create_http_api_budget(
+        self, model: HTTPAPIBudgetModel, config: Config, **kwargs: Any
+    ) -> HttpAPIBudget:
+        policies = [
+            self._create_component_from_model(model=policy, config=config)
+            for policy in model.policies
+        ]
+
+        return HttpAPIBudget(
+            policies=policies,
+            maximum_attempts_to_acquire=model.maximum_attempts_to_acquire or 100000,
+            ratelimit_reset_header=model.ratelimit_reset_header or "ratelimit-reset",
+            ratelimit_remaining_header=model.ratelimit_remaining_header or "ratelimit-remaining",
+            status_codes_for_ratelimit_hit=model.status_codes_for_ratelimit_hit or (429,),
+        )
+
+    def create_fixed_window_call_rate_policy(
+        self, model: FixedWindowCallRatePolicyModel, config: Config, **kwargs: Any
+    ) -> FixedWindowCallRatePolicy:
+        matchers = [
+            self._create_component_from_model(model=matcher, config=config)
+            for matcher in model.matchers
+        ]
+        return FixedWindowCallRatePolicy(
+            next_reset_ts=model.next_reset_ts,
+            period=parse_duration(model.period),
+            call_limit=model.call_limit,
+            matchers=matchers,
+        )
+
+    def create_moving_window_call_rate_policy(
+        self, model: MovingWindowCallRatePolicyModel, config: Config, **kwargs: Any
+    ) -> MovingWindowCallRatePolicy:
+        rates = [
+            self._create_component_from_model(model=rate, config=config) for rate in model.rates
+        ]
+        matchers = [
+            self._create_component_from_model(model=matcher, config=config)
+            for matcher in model.matchers
+        ]
+        return MovingWindowCallRatePolicy(
+            rates=rates,
+            matchers=matchers,
+        )
+
+    def create_unlimited_call_rate_policy(
+        self, model: UnlimitedCallRatePolicyModel, config: Config, **kwargs: Any
+    ) -> UnlimitedCallRatePolicy:
+        matchers = [
+            self._create_component_from_model(model=matcher, config=config)
+            for matcher in model.matchers
+        ]
+
+        return UnlimitedCallRatePolicy(
+            matchers=matchers,
+        )
+
+    def create_rate(self, model: RateModel, config: Config, **kwargs: Any) -> Rate:
+        return Rate(
+            limit=model.limit,
+            interval=model.interval,
+        )
+
+    def create_http_request_matcher(
+        self, model: HttpRequestMatcherModel, config: Config, **kwargs: Any
+    ) -> HttpRequestMatcher:
+        return HttpRequestMatcher(
+            method=model.method,
+            url_base=model.url_base,
+            url_path_pattern=model.url_path_pattern,
+            params=model.params,
+            headers=model.headers,
+        )
+
+    def set_api_budget(self, component_definition: ComponentDefinition, config: Config) -> None:
+        model_str = component_definition.get("type")
+        if model_str == "APIBudget":
+            # Annotate model_type as a type that is a subclass of BaseModel
+            model_type: Union[Type[APIBudgetModel], Type[HTTPAPIBudgetModel]] = APIBudgetModel
+        elif model_str == "HTTPAPIBudget":
+            model_type = HTTPAPIBudgetModel
+        else:
+            raise ValueError(f"Unknown API Budget type: {model_str}")
+
+        # create_component expects a type[BaseModel] and returns an instance of that model.
+        self._api_budget = self.create_component(
+            model_type=model_type, component_definition=component_definition, config=config
+        )

airbyte_cdk/sources/declarative/partition_routers/list_partition_router.py

@@ -3,7 +3,7 @@
 #
 
 from dataclasses import InitVar, dataclass
-from typing import Any, Iterable, List, Mapping, MutableMapping, Optional, Union
+from typing import Any, Iterable, List, Mapping, Optional, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
 from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
@@ -100,9 +100,7 @@ class ListPartitionRouter(PartitionRouter):
         ):
             slice_value = stream_slice.get(self._cursor_field.eval(self.config))
             if slice_value:
-                options: MutableMapping[str, Any] = {}
-                self.request_option.inject_into_request(options, slice_value, self.config)
-                return options
+                return {self.request_option.field_name.eval(self.config): slice_value}  # type: ignore # field_name is always casted to InterpolatedString
             else:
                 return {}
         else:

airbyte_cdk/sources/declarative/partition_routers/substream_partition_router.py

@@ -4,7 +4,7 @@
 import copy
 import logging
 from dataclasses import InitVar, dataclass
-from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, MutableMapping, Optional, Union
+from typing import TYPE_CHECKING, Any, Iterable, List, Mapping, Optional, Union
 
 import dpath
 
@@ -118,7 +118,7 @@ class SubstreamPartitionRouter(PartitionRouter):
     def _get_request_option(
         self, option_type: RequestOptionType, stream_slice: Optional[StreamSlice]
     ) -> Mapping[str, Any]:
-        params: MutableMapping[str, Any] = {}
+        params = {}
         if stream_slice:
             for parent_config in self.parent_stream_configs:
                 if (
@@ -128,7 +128,13 @@ class SubstreamPartitionRouter(PartitionRouter):
                     key = parent_config.partition_field.eval(self.config)  # type: ignore # partition_field is always casted to an interpolated string
                     value = stream_slice.get(key)
                     if value:
-                        parent_config.request_option.inject_into_request(params, value, self.config)
+                        params.update(
+                            {
+                                parent_config.request_option.field_name.eval(  # type: ignore [union-attr]
+                                    config=self.config
+                                ): value
+                            }
+                        )
         return params
 
     def stream_slices(self) -> Iterable[StreamSlice]:

airbyte_cdk/sources/declarative/requesters/http_requester.py

@@ -22,6 +22,7 @@ from airbyte_cdk.sources.declarative.requesters.request_options.interpolated_req
 )
 from airbyte_cdk.sources.declarative.requesters.requester import HttpMethod, Requester
 from airbyte_cdk.sources.message import MessageRepository, NoopMessageRepository
+from airbyte_cdk.sources.streams.call_rate import APIBudget
 from airbyte_cdk.sources.streams.http import HttpClient
 from airbyte_cdk.sources.streams.http.error_handlers import ErrorHandler
 from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
@@ -55,6 +56,7 @@ class HttpRequester(Requester):
     http_method: Union[str, HttpMethod] = HttpMethod.GET
     request_options_provider: Optional[InterpolatedRequestOptionsProvider] = None
     error_handler: Optional[ErrorHandler] = None
+    api_budget: Optional[APIBudget] = None
     disable_retries: bool = False
     message_repository: MessageRepository = NoopMessageRepository()
     use_cache: bool = False
@@ -91,6 +93,7 @@ class HttpRequester(Requester):
             name=self.name,
             logger=self.logger,
             error_handler=self.error_handler,
+            api_budget=self.api_budget,
             authenticator=self._authenticator,
             use_cache=self.use_cache,
             backoff_strategy=backoff_strategies,
@@ -199,9 +202,6 @@ class HttpRequester(Requester):
         Raise a ValueError if there's a key collision
         Returned merged mapping otherwise
         """
-
-        is_body_json = requester_method.__name__ == "get_request_body_json"
-
         return combine_mappings(
             [
                 requester_method(
@@ -211,8 +211,7 @@ class HttpRequester(Requester):
                 ),
                 auth_options_method(),
                 extra_options,
-            ],
-            allow_same_value_merge=is_body_json,
+            ]
         )
 
     def _request_headers(

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

@@ -187,7 +187,7 @@ class DefaultPaginator(Paginator):
     def _get_request_options(
         self, option_type: RequestOptionType, next_page_token: Optional[Mapping[str, Any]]
     ) -> MutableMapping[str, Any]:
-        options: MutableMapping[str, Any] = {}
+        options = {}
 
         token = next_page_token.get("next_page_token") if next_page_token else None
         if (
@@ -196,16 +196,15 @@ class DefaultPaginator(Paginator):
             and isinstance(self.page_token_option, RequestOption)
             and self.page_token_option.inject_into == option_type
         ):
-            self.page_token_option.inject_into_request(options, token, self.config)
-
+            options[self.page_token_option.field_name.eval(config=self.config)] = token  # type: ignore # field_name is always cast to an interpolated string
         if (
             self.page_size_option
             and self.pagination_strategy.get_page_size()
             and self.page_size_option.inject_into == option_type
         ):
-            page_size = self.pagination_strategy.get_page_size()
-            self.page_size_option.inject_into_request(options, page_size, self.config)
-
+            options[self.page_size_option.field_name.eval(config=self.config)] = (  # type: ignore [union-attr]
+                self.pagination_strategy.get_page_size()
+            )  # type: ignore # field_name is always cast to an interpolated string
         return options
 
 

airbyte_cdk/sources/declarative/requesters/request_option.py

@@ -4,10 +4,9 @@
 
 from dataclasses import InitVar, dataclass
 from enum import Enum
-from typing import Any, List, Literal, Mapping, MutableMapping, Optional, Union
+from typing import Any, Mapping, Union
 
 from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
-from airbyte_cdk.sources.types import Config
 
 
 class RequestOptionType(Enum):
@@ -27,91 +26,13 @@ class RequestOption:
     Describes an option to set on a request
 
     Attributes:
-        field_name (str): Describes the name of the parameter to inject. Mutually exclusive with field_path.
-        field_path (list(str)): Describes the path to a nested field as a list of field names.
-          Only valid for body_json injection type, and mutually exclusive with field_name.
+        field_name (str): Describes the name of the parameter to inject
         inject_into (RequestOptionType): Describes where in the HTTP request to inject the parameter
     """
 
+    field_name: Union[InterpolatedString, str]
     inject_into: RequestOptionType
     parameters: InitVar[Mapping[str, Any]]
-    field_name: Optional[Union[InterpolatedString, str]] = None
-    field_path: Optional[List[Union[InterpolatedString, str]]] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
-        # Validate inputs. We should expect either field_name or field_path, but not both
-        if self.field_name is None and self.field_path is None:
-            raise ValueError("RequestOption requires either a field_name or field_path")
-
-        if self.field_name is not None and self.field_path is not None:
-            raise ValueError(
-                "Only one of field_name or field_path can be provided to RequestOption"
-            )
-
-        # Nested field injection is only supported for body JSON injection
-        if self.field_path is not None and self.inject_into != RequestOptionType.body_json:
-            raise ValueError(
-                "Nested field injection is only supported for body JSON injection. Please use a top-level field_name for other injection types."
-            )
-
-        # Convert field_name and field_path into InterpolatedString objects if they are strings
-        if self.field_name is not None:
-            self.field_name = InterpolatedString.create(self.field_name, parameters=parameters)
-        elif self.field_path is not None:
-            self.field_path = [
-                InterpolatedString.create(segment, parameters=parameters)
-                for segment in self.field_path
-            ]
-
-    @property
-    def _is_field_path(self) -> bool:
-        """Returns whether this option is a field path (ie, a nested field)"""
-        return self.field_path is not None
-
-    def inject_into_request(
-        self,
-        target: MutableMapping[str, Any],
-        value: Any,
-        config: Config,
-    ) -> None:
-        """
-        Inject a request option value into a target request structure using either field_name or field_path.
-        For non-body-json injection, only top-level field names are supported.
-        For body-json injection, both field names and nested field paths are supported.
-
-        Args:
-            target: The request structure to inject the value into
-            value: The value to inject
-            config: The config object to use for interpolation
-        """
-        if self._is_field_path:
-            if self.inject_into != RequestOptionType.body_json:
-                raise ValueError(
-                    "Nested field injection is only supported for body JSON injection. Please use a top-level field_name for other injection types."
-                )
-
-            assert self.field_path is not None  # for type checker
-            current = target
-            # Convert path segments into strings, evaluating any interpolated segments
-            # Example: ["data", "{{ config[user_type] }}", "id"] -> ["data", "admin", "id"]
-            *path_parts, final_key = [
-                str(
-                    segment.eval(config=config)
-                    if isinstance(segment, InterpolatedString)
-                    else segment
-                )
-                for segment in self.field_path
-            ]
-
-            # Build a nested dictionary structure and set the final value at the deepest level
-            for part in path_parts:
-                current = current.setdefault(part, {})
-            current[final_key] = value
-        else:
-            # For non-nested fields, evaluate the field name if it's an interpolated string
-            key = (
-                self.field_name.eval(config=config)
-                if isinstance(self.field_name, InterpolatedString)
-                else self.field_name
-            )
-            target[str(key)] = value
+        self.field_name = InterpolatedString.create(self.field_name, parameters=parameters)

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

@@ -80,13 +80,12 @@ class DatetimeBasedRequestOptionsProvider(RequestOptionsProvider):
         options: MutableMapping[str, Any] = {}
         if not stream_slice:
             return options
-
         if self.start_time_option and self.start_time_option.inject_into == option_type:
-            start_time_value = stream_slice.get(self._partition_field_start.eval(self.config))
-            self.start_time_option.inject_into_request(options, start_time_value, self.config)
-
+            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:
-            end_time_value = stream_slice.get(self._partition_field_end.eval(self.config))
-            self.end_time_option.inject_into_request(options, end_time_value, self.config)
-
+            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/retrievers/simple_retriever.py

@@ -128,9 +128,6 @@ class SimpleRetriever(Retriever):
         Returned merged mapping otherwise
         """
         # FIXME we should eventually remove the usage of stream_state as part of the interpolation
-
-        is_body_json = paginator_method.__name__ == "get_request_body_json"
-
         mappings = [
             paginator_method(
                 stream_state=stream_state,
@@ -146,7 +143,7 @@ class SimpleRetriever(Retriever):
                     next_page_token=next_page_token,
                 )
             )
-        return combine_mappings(mappings, allow_same_value_merge=is_body_json)
+        return combine_mappings(mappings)
 
     def _request_headers(
         self,