airbyte-cdk 6.43.0.dev0__py3-none-any.whl → 6.44.0__py3-none-any.whl

airbyte_cdk/sources/declarative/parsers/manifest_component_transformer.py

@@ -4,7 +4,7 @@
 
 import copy
 import typing
-from typing import Any, Mapping
+from typing import Any, Mapping, Optional
 
 PARAMETERS_STR = "$parameters"
 
@@ -94,6 +94,7 @@ class ManifestComponentTransformer:
         parent_field_identifier: str,
         declarative_component: Mapping[str, Any],
         parent_parameters: Mapping[str, Any],
+        use_parent_parameters: Optional[bool] = None,
     ) -> Mapping[str, Any]:
         """
         Recursively transforms the specified declarative component and subcomponents to propagate parameters and insert the
@@ -103,6 +104,7 @@ class ManifestComponentTransformer:
         :param declarative_component: The current component that is having type and parameters added
         :param parent_field_identifier: The name of the field of the current component coming from the parent component
         :param parent_parameters: The parameters set on parent components defined before the current component
+        :param use_parent_parameters: If set, parent parameters will be used as the source of truth when key names are the same
         :return: A deep copy of the transformed component with types and parameters persisted to it
         """
         propagated_component = dict(copy.deepcopy(declarative_component))
@@ -130,7 +132,11 @@ class ManifestComponentTransformer:
         # level take precedence
         current_parameters = dict(copy.deepcopy(parent_parameters))
         component_parameters = propagated_component.pop(PARAMETERS_STR, {})
-        current_parameters = {**current_parameters, **component_parameters}
+        current_parameters = (
+            {**component_parameters, **current_parameters}
+            if use_parent_parameters
+            else {**current_parameters, **component_parameters}
+        )
 
         # Parameters should be applied to the current component fields with the existing field taking precedence over parameters if
         # both exist
@@ -145,7 +151,10 @@ class ManifestComponentTransformer:
                 excluded_parameter = current_parameters.pop(field_name, None)
                 parent_type_field_identifier = f"{propagated_component.get('type')}.{field_name}"
                 propagated_component[field_name] = self.propagate_types_and_parameters(
-                    parent_type_field_identifier, field_value, current_parameters
+                    parent_type_field_identifier,
+                    field_value,
+                    current_parameters,
+                    use_parent_parameters=use_parent_parameters,
                 )
                 if excluded_parameter:
                     current_parameters[field_name] = excluded_parameter
@@ -158,7 +167,10 @@ class ManifestComponentTransformer:
                             f"{propagated_component.get('type')}.{field_name}"
                         )
                         field_value[i] = self.propagate_types_and_parameters(
-                            parent_type_field_identifier, element, current_parameters
+                            parent_type_field_identifier,
+                            element,
+                            current_parameters,
+                            use_parent_parameters=use_parent_parameters,
                         )
                 if excluded_parameter:
                     current_parameters[field_name] = excluded_parameter

airbyte_cdk/sources/declarative/parsers/model_to_component_factory.py

@@ -1,5 +1,5 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 from __future__ import annotations
@@ -54,7 +54,11 @@ from airbyte_cdk.sources.declarative.auth.token_provider import (
     SessionTokenProvider,
     TokenProvider,
 )
-from airbyte_cdk.sources.declarative.checks import CheckDynamicStream, CheckStream
+from airbyte_cdk.sources.declarative.checks import (
+    CheckDynamicStream,
+    CheckStream,
+    DynamicStreamCheckConfig,
+)
 from airbyte_cdk.sources.declarative.concurrency_level import ConcurrencyLevel
 from airbyte_cdk.sources.declarative.datetime.min_max_datetime import MinMaxDatetime
 from airbyte_cdk.sources.declarative.declarative_stream import DeclarativeStream
@@ -218,6 +222,9 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     DynamicSchemaLoader as DynamicSchemaLoaderModel,
 )
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
+    DynamicStreamCheckConfig as DynamicStreamCheckConfigModel,
+)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     ExponentialBackoffStrategy as ExponentialBackoffStrategyModel,
 )
@@ -227,9 +234,6 @@ from airbyte_cdk.sources.declarative.models.declarative_component_schema import
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     FlattenFields as FlattenFieldsModel,
 )
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
-    GroupByKeyMergeStrategy as GroupByKeyMergeStrategyModel,
-)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     GroupingPartitionRouter as GroupingPartitionRouterModel,
 )
@@ -320,18 +324,6 @@ 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 (
-    PropertiesFromEndpoint as PropertiesFromEndpointModel,
-)
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
-    PropertyChunking as PropertyChunkingModel,
-)
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
-    PropertyLimitType as PropertyLimitTypeModel,
-)
-from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
-    QueryProperties as QueryPropertiesModel,
-)
 from airbyte_cdk.sources.declarative.models.declarative_component_schema import (
     Rate as RateModel,
 )
@@ -440,15 +432,6 @@ from airbyte_cdk.sources.declarative.requesters.paginators.strategies import (
     PageIncrement,
     StopConditionPaginationStrategyDecorator,
 )
-from airbyte_cdk.sources.declarative.requesters.query_properties import (
-    GroupByKey,
-    PropertiesFromEndpoint,
-    PropertyChunking,
-    QueryProperties,
-)
-from airbyte_cdk.sources.declarative.requesters.query_properties.property_chunking import (
-    PropertyLimitType,
-)
 from airbyte_cdk.sources.declarative.requesters.request_option import RequestOptionType
 from airbyte_cdk.sources.declarative.requesters.request_options import (
     DatetimeBasedRequestOptionsProvider,
@@ -583,6 +566,7 @@ class ModelToComponentFactory:
             BasicHttpAuthenticatorModel: self.create_basic_http_authenticator,
             BearerAuthenticatorModel: self.create_bearer_authenticator,
             CheckStreamModel: self.create_check_stream,
+            DynamicStreamCheckConfigModel: self.create_dynamic_stream_check_config,
             CheckDynamicStreamModel: self.create_check_dynamic_stream,
             CompositeErrorHandlerModel: self.create_composite_error_handler,
             ConcurrencyLevelModel: self.create_concurrency_level,
@@ -612,7 +596,6 @@ class ModelToComponentFactory:
             ResponseToFileExtractorModel: self.create_response_to_file_extractor,
             ExponentialBackoffStrategyModel: self.create_exponential_backoff_strategy,
             SessionTokenAuthenticatorModel: self.create_session_token_authenticator,
-            GroupByKeyMergeStrategyModel: self.create_group_by_key,
             HttpRequesterModel: self.create_http_requester,
             HttpResponseFilterModel: self.create_http_response_filter,
             InlineSchemaLoaderModel: self.create_inline_schema_loader,
@@ -642,9 +625,6 @@ class ModelToComponentFactory:
             OffsetIncrementModel: self.create_offset_increment,
             PageIncrementModel: self.create_page_increment,
             ParentStreamConfigModel: self.create_parent_stream_config,
-            PropertiesFromEndpointModel: self.create_properties_from_endpoint,
-            PropertyChunkingModel: self.create_property_chunking,
-            QueryPropertiesModel: self.create_query_properties,
             RecordFilterModel: self.create_record_filter,
             RecordSelectorModel: self.create_record_selector,
             RemoveFieldsModel: self.create_remove_fields,
@@ -964,8 +944,36 @@ class ModelToComponentFactory:
         )
 
     @staticmethod
-    def create_check_stream(model: CheckStreamModel, config: Config, **kwargs: Any) -> CheckStream:
-        return CheckStream(stream_names=model.stream_names, parameters={})
+    def create_dynamic_stream_check_config(
+        model: DynamicStreamCheckConfigModel, config: Config, **kwargs: Any
+    ) -> DynamicStreamCheckConfig:
+        return DynamicStreamCheckConfig(
+            dynamic_stream_name=model.dynamic_stream_name,
+            stream_count=model.stream_count or 0,
+        )
+
+    def create_check_stream(
+        self, model: CheckStreamModel, config: Config, **kwargs: Any
+    ) -> CheckStream:
+        if model.dynamic_streams_check_configs is None and model.stream_names is None:
+            raise ValueError(
+                "Expected either stream_names or dynamic_streams_check_configs to be set for CheckStream"
+            )
+
+        dynamic_streams_check_configs = (
+            [
+                self._create_component_from_model(model=dynamic_stream_check_config, config=config)
+                for dynamic_stream_check_config in model.dynamic_streams_check_configs
+            ]
+            if model.dynamic_streams_check_configs
+            else []
+        )
+
+        return CheckStream(
+            stream_names=model.stream_names or [],
+            dynamic_streams_check_configs=dynamic_streams_check_configs,
+            parameters={},
+        )
 
     @staticmethod
     def create_check_dynamic_stream(
@@ -2075,8 +2083,8 @@ class ModelToComponentFactory:
             parameters=model.parameters or {},
         )
 
-    @staticmethod
     def create_response_to_file_extractor(
+        self,
         model: ResponseToFileExtractorModel,
         **kwargs: Any,
     ) -> ResponseToFileExtractor:
@@ -2090,16 +2098,11 @@ class ModelToComponentFactory:
             factor=model.factor or 5, parameters=model.parameters or {}, config=config
         )
 
-    @staticmethod
-    def create_group_by_key(model: GroupByKeyMergeStrategyModel, config: Config) -> GroupByKey:
-        return GroupByKey(model.key, config=config, parameters=model.parameters or {})
-
     def create_http_requester(
         self,
         model: HttpRequesterModel,
         config: Config,
         decoder: Decoder = JsonDecoder(parameters={}),
-        query_properties_key: Optional[str] = None,
         *,
         name: str,
     ) -> HttpRequester:
@@ -2132,7 +2135,6 @@ class ModelToComponentFactory:
             request_body_json=model.request_body_json,
             request_headers=model.request_headers,
             request_parameters=model.request_parameters,
-            query_properties_key=query_properties_key,
             config=config,
             parameters=model.parameters or {},
         )
@@ -2600,79 +2602,6 @@ class ModelToComponentFactory:
             lazy_read_pointer=model_lazy_read_pointer,
         )
 
-    def create_properties_from_endpoint(
-        self, model: PropertiesFromEndpointModel, config: Config, **kwargs: Any
-    ) -> PropertiesFromEndpoint:
-        name = "property_retriever"
-        retriever = self._create_component_from_model(
-            model=model.retriever,
-            config=config,
-            name=name,
-            primary_key=None,
-            stream_slicer=None,
-            transformations=[],
-        )
-        return PropertiesFromEndpoint(
-            property_field_path=model.property_field_path,
-            retriever=retriever,
-            config=config,
-            parameters=model.parameters or {},
-        )
-
-    def create_property_chunking(
-        self, model: PropertyChunkingModel, config: Config, **kwargs: Any
-    ) -> PropertyChunking:
-        record_merge_strategy = (
-            self._create_component_from_model(
-                model=model.record_merge_strategy, config=config, **kwargs
-            )
-            if model.record_merge_strategy
-            else None
-        )
-
-        property_limit_type: PropertyLimitType
-        match model.property_limit_type:
-            case PropertyLimitTypeModel.property_count:
-                property_limit_type = PropertyLimitType.property_count
-            case PropertyLimitTypeModel.characters:
-                property_limit_type = PropertyLimitType.characters
-            case _:
-                raise ValueError(f"Invalid PropertyLimitType {property_limit_type}")
-
-        return PropertyChunking(
-            property_limit_type=property_limit_type,
-            property_limit=model.property_limit,
-            record_merge_strategy=record_merge_strategy,
-            config=config,
-            parameters=model.parameters or {},
-        )
-
-    def create_query_properties(
-        self, model: QueryPropertiesModel, config: Config, **kwargs: Any
-    ) -> QueryProperties:
-        if isinstance(model.property_list, list):
-            property_list = model.property_list
-        else:
-            property_list = self._create_component_from_model(
-                model=model.property_list, config=config, **kwargs
-            )
-
-        property_chunking = (
-            self._create_component_from_model(
-                model=model.property_chunking, config=config, **kwargs
-            )
-            if model.property_chunking
-            else None
-        )
-
-        return QueryProperties(
-            property_list=property_list,
-            always_include_properties=model.always_include_properties,
-            property_chunking=property_chunking,
-            config=config,
-            parameters=model.parameters or {},
-        )
-
     @staticmethod
     def create_record_filter(
         model: RecordFilterModel, config: Config, **kwargs: Any
@@ -2825,6 +2754,9 @@ class ModelToComponentFactory:
             if model.decoder
             else JsonDecoder(parameters={})
         )
+        requester = self._create_component_from_model(
+            model=model.requester, decoder=decoder, config=config, name=name
+        )
         record_selector = self._create_component_from_model(
             model=model.record_selector,
             name=name,
@@ -2833,53 +2765,6 @@ class ModelToComponentFactory:
             transformations=transformations,
             client_side_incremental_sync=client_side_incremental_sync,
         )
-
-        query_properties: Optional[QueryProperties] = None
-        query_properties_key: Optional[str] = None
-        if (
-            hasattr(model.requester, "request_parameters")
-            and model.requester.request_parameters
-            and isinstance(model.requester.request_parameters, Mapping)
-        ):
-            query_properties_definitions = []
-            for key, request_parameter in model.requester.request_parameters.items():
-                if (
-                    isinstance(request_parameter, Mapping)
-                    and request_parameter.get("type") == "QueryProperties"
-                ):
-                    query_properties_key = key
-                    query_properties_definitions.append(request_parameter)
-                elif not isinstance(request_parameter, str):
-                    raise ValueError(
-                        f"Each element of request_parameters should be of type str or QueryProperties, but received {request_parameter.get('type')}"
-                    )
-
-            if len(query_properties_definitions) > 1:
-                raise ValueError(
-                    f"request_parameters should only define one QueryProperties field, but found {len(query_properties_definitions)}"
-                )
-
-            if len(query_properties_definitions) == 1:
-                query_properties = self.create_component(
-                    model_type=QueryPropertiesModel,
-                    component_definition=query_properties_definitions[0],
-                    config=config,
-                )
-
-            # Removes QueryProperties components from the interpolated mappings because it will be resolved in
-            # the provider from the slice directly instead of through jinja interpolation
-            if isinstance(model.requester.request_parameters, Mapping):
-                model.requester.request_parameters = self._remove_query_properties(
-                    model.requester.request_parameters
-                )
-
-        requester = self._create_component_from_model(
-            model=model.requester,
-            decoder=decoder,
-            query_properties_key=query_properties_key,
-            config=config,
-            name=name,
-        )
         url_base = (
             model.requester.url_base
             if hasattr(model.requester, "url_base")
@@ -2985,42 +2870,9 @@ class ModelToComponentFactory:
             cursor=cursor,
             config=config,
             ignore_stream_slicer_parameters_on_paginated_requests=ignore_stream_slicer_parameters_on_paginated_requests,
-            additional_query_properties=query_properties,
             parameters=model.parameters or {},
         )
 
-    @staticmethod
-    def _remove_query_properties(
-        request_parameters: Mapping[str, Union[Any, str]],
-    ) -> Mapping[str, Union[Any, str]]:
-        return {
-            parameter_field: request_parameter
-            for parameter_field, request_parameter in request_parameters.items()
-            if not isinstance(request_parameter, Mapping)
-            or not request_parameter.get("type") == "QueryProperties"
-        }
-
-    @staticmethod
-    def _translate_query_properties_to_interpolated_strings(
-        request_parameters: Mapping[str, Union[Any, str]],
-    ) -> Mapping[str, Union[Any, str]]:
-        # todo blai: remove this since unused
-        new_request_parameters = dict()
-        for key, request_parameter in request_parameters.items():
-            if (
-                isinstance(request_parameter, Mapping)
-                and request_parameter.get("type") == "QueryProperties"
-            ):
-                # This may seem like this could be combined into the above conditional, but this is separated
-                # so that we do not add the properties into the new request_parameters mapping
-                if request_parameter.get("inject_into"):
-                    new_request_parameters[key] = (
-                        "{{ stream_partition.extra_fields['query_properties'] }}"
-                    )
-            else:
-                new_request_parameters[key] = request_parameter
-        return new_request_parameters
-
     def create_state_delegating_stream(
         self,
         model: StateDelegatingStreamModel,

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

@@ -1,9 +1,9 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 from dataclasses import InitVar, dataclass, field
-from typing import Any, List, Mapping, MutableMapping, Optional, Union
+from typing import Any, Mapping, MutableMapping, Optional, Union
 
 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 (
@@ -40,7 +40,6 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
     request_headers: Optional[RequestInput] = None
     request_body_data: Optional[RequestInput] = None
     request_body_json: Optional[NestedMapping] = None
-    query_properties_key: Optional[str] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         if self.request_parameters is None:
@@ -84,28 +83,6 @@ class InterpolatedRequestOptionsProvider(RequestOptionsProvider):
             valid_value_types=ValidRequestTypes,
         )
         if isinstance(interpolated_value, dict):
-            if self.query_properties_key:
-                if not stream_slice:
-                    raise ValueError(
-                        "stream_slice should not be None if query properties in requests is enabled. Please contact Airbyte Support"
-                    )
-                elif (
-                    "query_properties" not in stream_slice.extra_fields
-                    or stream_slice.extra_fields.get("query_properties") is None
-                ):
-                    raise ValueError(
-                        "QueryProperties component is defined but stream_partition does not contain query_properties. Please contact Airbyte Support"
-                    )
-                elif not isinstance(stream_slice.extra_fields.get("query_properties"), List):
-                    raise ValueError(
-                        "QueryProperties component is defined but stream_slice.extra_fields.query_properties is not a List. Please contact Airbyte Support"
-                    )
-                interpolated_value = {
-                    **interpolated_value,
-                    self.query_properties_key: ",".join(
-                        stream_slice.extra_fields.get("query_properties")  # type: ignore  # Earlier type checks validate query_properties type
-                    ),
-                }
             return interpolated_value
         return {}
 

airbyte_cdk/sources/declarative/retrievers/simple_retriever.py

@@ -1,9 +1,8 @@
 #
-# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
 #
 
 import json
-from collections import defaultdict
 from dataclasses import InitVar, dataclass, field
 from functools import partial
 from itertools import islice
@@ -13,7 +12,6 @@ from typing import (
     Iterable,
     List,
     Mapping,
-    MutableMapping,
     Optional,
     Set,
     Tuple,
@@ -33,7 +31,6 @@ from airbyte_cdk.sources.declarative.partition_routers.single_partition_router i
 )
 from airbyte_cdk.sources.declarative.requesters.paginators.no_pagination import NoPagination
 from airbyte_cdk.sources.declarative.requesters.paginators.paginator import Paginator
-from airbyte_cdk.sources.declarative.requesters.query_properties import QueryProperties
 from airbyte_cdk.sources.declarative.requesters.request_options import (
     DefaultRequestOptionsProvider,
     RequestOptionsProvider,
@@ -91,7 +88,6 @@ class SimpleRetriever(Retriever):
     )
     cursor: Optional[DeclarativeCursor] = None
     ignore_stream_slicer_parameters_on_paginated_requests: bool = False
-    additional_query_properties: Optional[QueryProperties] = None
 
     def __post_init__(self, parameters: Mapping[str, Any]) -> None:
         self._paginator = self.paginator or NoPagination(parameters=parameters)
@@ -449,108 +445,43 @@ class SimpleRetriever(Retriever):
         :param stream_slice: The stream slice to read data for
         :return: The records read from the API source
         """
-
-        if self.additional_query_properties:
-            property_chunks = list(
-                self.additional_query_properties.get_request_property_chunks(
-                    stream_slice=stream_slice
-                )
-            )
-            has_multiple_chunks = self.additional_query_properties.has_multiple_chunks(
-                stream_slice=stream_slice
-            )
-        else:
-            property_chunks = [[""]]
-            has_multiple_chunks = False
-        merged_records: MutableMapping[str, Any] = defaultdict(dict)
         _slice = stream_slice or StreamSlice(partition={}, cursor_slice={})  # None-check
+
         most_recent_record_from_slice = None
+        record_generator = partial(
+            self._parse_records,
+            stream_slice=stream_slice,
+            stream_state=self.state or {},
+            records_schema=records_schema,
+        )
 
-        if self.additional_query_properties:
-            for properties in property_chunks:
-                _slice = StreamSlice(
-                    partition=_slice.partition or {},
-                    cursor_slice=_slice.cursor_slice or {},
-                    extra_fields={"query_properties": properties},
-                )  # None-check
-
-                record_generator = partial(
-                    self._parse_records,
-                    stream_slice=_slice,
-                    stream_state=self.state or {},
-                    records_schema=records_schema,
-                )
+        if self.cursor and isinstance(self.cursor, ResumableFullRefreshCursor):
+            stream_state = self.state
 
-                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:
-                        self.cursor.observe(_slice, current_record)
-
-                    # Latest record read, not necessarily within slice boundaries.
-                    # TODO Remove once all custom components implement `observe` method.
-                    # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
-                    most_recent_record_from_slice = self._get_most_recent_record(
-                        most_recent_record_from_slice, current_record, _slice
-                    )
-
-                    # Record merging should only be done if there are multiple property chunks. Otherwise,
-                    # yielding immediately is more efficient so records can be emitted immediately
-                    if (
-                        has_multiple_chunks
-                        and self.additional_query_properties.property_chunking
-                        and current_record
-                    ):
-                        merge_key = (
-                            self.additional_query_properties.property_chunking.get_merge_key(
-                                current_record
-                            )
-                        )
-                        merged_records[merge_key].update(current_record)
-                    else:
-                        yield stream_data
-            if self.cursor:
-                self.cursor.close_slice(_slice, most_recent_record_from_slice)
+            # 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
 
-            if has_multiple_chunks:
-                yield from merged_records.values()
+            yield from self._read_single_page(record_generator, stream_state, _slice)
         else:
-            _slice = stream_slice or StreamSlice(partition={}, cursor_slice={})  # None-check
-
-            most_recent_record_from_slice = None
-            record_generator = partial(
-                self._parse_records,
-                stream_slice=stream_slice,
-                stream_state=self.state or {},
-                records_schema=records_schema,
-            )
-
-            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
-                if stream_state.get(FULL_REFRESH_SYNC_COMPLETE_KEY):
-                    return
+            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:
+                    self.cursor.observe(_slice, current_record)
+
+                # Latest record read, not necessarily within slice boundaries.
+                # TODO Remove once all custom components implement `observe` method.
+                # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
+                most_recent_record_from_slice = self._get_most_recent_record(
+                    most_recent_record_from_slice, current_record, _slice
+                )
+                yield stream_data
 
-                yield from self._read_single_page(record_generator, stream_state, _slice)
-            else:
-                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:
-                        self.cursor.observe(_slice, current_record)
-
-                    # Latest record read, not necessarily within slice boundaries.
-                    # TODO Remove once all custom components implement `observe` method.
-                    # https://github.com/airbytehq/airbyte-internal-issues/issues/6955
-                    most_recent_record_from_slice = self._get_most_recent_record(
-                        most_recent_record_from_slice, current_record, _slice
-                    )
-                    yield stream_data
-
-                if self.cursor:
-                    self.cursor.close_slice(_slice, most_recent_record_from_slice)
-            return
+            if self.cursor:
+                self.cursor.close_slice(_slice, most_recent_record_from_slice)
+        return
 
     def _get_most_recent_record(
         self,

airbyte_cdk/sources/declarative/transformations/add_fields.py

@@ -139,7 +139,9 @@ class AddFields(RecordTransformation):
             valid_types = (parsed_field.value_type,) if parsed_field.value_type else None
             value = parsed_field.value.eval(config, valid_types=valid_types, **kwargs)
             is_empty_condition = not self.condition
-            if is_empty_condition or self._filter_interpolator.eval(config, value=value, **kwargs):
+            if is_empty_condition or self._filter_interpolator.eval(
+                config, value=value, path=parsed_field.path, **kwargs
+            ):
                 dpath.new(record, parsed_field.path, value)
 
     def __eq__(self, other: Any) -> bool:

{airbyte_cdk-6.43.0.dev0.dist-info → airbyte_cdk-6.44.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: airbyte-cdk
-Version: 6.43.0.dev0
+Version: 6.44.0
 Summary: A framework for writing Airbyte Connectors.
 Home-page: https://airbyte.com
 License: MIT