airbyte-cdk 6.45.0.dev4107__py3-none-any.whl → 6.45.0.post20.dev14369762306__py3-none-any.whl

airbyte_cdk/sources/declarative/partition_routers/grouping_partition_router.py

@@ -0,0 +1,150 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from dataclasses import dataclass
+from typing import Any, Iterable, Mapping, Optional
+
+from airbyte_cdk.sources.declarative.partition_routers.partition_router import PartitionRouter
+from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
+
+
+@dataclass
+class GroupingPartitionRouter(PartitionRouter):
+    """
+    A partition router that groups partitions from an underlying partition router into batches of a specified size.
+    This is useful for APIs that support filtering by multiple partition keys in a single request.
+
+    Attributes:
+        group_size (int): The number of partitions to include in each group.
+        underlying_partition_router (PartitionRouter): The partition router whose output will be grouped.
+        deduplicate (bool): If True, ensures unique partitions within each group by removing duplicates based on the partition key.
+        config (Config): The connector configuration.
+        parameters (Mapping[str, Any]): Additional parameters for interpolation and configuration.
+    """
+
+    group_size: int
+    underlying_partition_router: PartitionRouter
+    config: Config
+    deduplicate: bool = True
+
+    def __post_init__(self) -> None:
+        self._state: Optional[Mapping[str, StreamState]] = {}
+
+    def stream_slices(self) -> Iterable[StreamSlice]:
+        """
+        Lazily groups partitions from the underlying partition router into batches of size `group_size`.
+
+        This method processes partitions one at a time from the underlying router, maintaining a batch buffer.
+        When the buffer reaches `group_size` or the underlying router is exhausted, it yields a grouped slice.
+        If deduplication is enabled, it tracks seen partition keys to ensure uniqueness within the current batch.
+
+        Yields:
+            Iterable[StreamSlice]: An iterable of StreamSlice objects, where each slice contains a batch of partition values.
+        """
+        batch = []
+        seen_keys = set()
+
+        # Iterate over partitions lazily from the underlying router
+        for partition in self.underlying_partition_router.stream_slices():
+            # Extract the partition key (assuming single key-value pair, e.g., {"board_ids": value})
+            partition_keys = list(partition.partition.keys())
+            # skip parent_slice as it is part of SubstreamPartitionRouter partition
+            if "parent_slice" in partition_keys:
+                partition_keys.remove("parent_slice")
+            if len(partition_keys) != 1:
+                raise ValueError(
+                    f"GroupingPartitionRouter expects a single partition key-value pair. Got {partition.partition}"
+                )
+            key = partition.partition[partition_keys[0]]
+
+            # Skip duplicates if deduplication is enabled
+            if self.deduplicate and key in seen_keys:
+                continue
+
+            # Add partition to the batch
+            batch.append(partition)
+            if self.deduplicate:
+                seen_keys.add(key)
+
+            # Yield the batch when it reaches the group_size
+            if len(batch) == self.group_size:
+                self._state = self.underlying_partition_router.get_stream_state()
+                yield self._create_grouped_slice(batch)
+                batch = []  # Reset the batch
+
+        self._state = self.underlying_partition_router.get_stream_state()
+        # Yield any remaining partitions if the batch isn't empty
+        if batch:
+            yield self._create_grouped_slice(batch)
+
+    def _create_grouped_slice(self, batch: list[StreamSlice]) -> StreamSlice:
+        """
+        Creates a grouped StreamSlice from a batch of partitions, aggregating extra fields into a dictionary with list values.
+
+        Args:
+            batch (list[StreamSlice]): A list of StreamSlice objects to group.
+
+        Returns:
+            StreamSlice: A single StreamSlice with combined partition and extra field values.
+        """
+        # Combine partition values into a single dict with lists
+        grouped_partition = {
+            key: [p.partition.get(key) for p in batch] for key in batch[0].partition.keys()
+        }
+
+        # Aggregate extra fields into a dict with list values
+        extra_fields_dict = (
+            {
+                key: [p.extra_fields.get(key) for p in batch]
+                for key in set().union(*(p.extra_fields.keys() for p in batch if p.extra_fields))
+            }
+            if any(p.extra_fields for p in batch)
+            else {}
+        )
+        return StreamSlice(
+            partition=grouped_partition,
+            cursor_slice={},  # Cursor is managed by the underlying router or incremental sync
+            extra_fields=extra_fields_dict,
+        )
+
+    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,
+    ) -> Mapping[str, Any]:
+        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 {}
+
+    def set_initial_state(self, stream_state: StreamState) -> None:
+        """Delegate state initialization to the underlying partition router."""
+        self.underlying_partition_router.set_initial_state(stream_state)
+        self._state = self.underlying_partition_router.get_stream_state()
+
+    def get_stream_state(self) -> Optional[Mapping[str, StreamState]]:
+        """Delegate state retrieval to the underlying partition router."""
+        return self._state

airbyte_cdk/sources/declarative/partition_routers/substream_partition_router.py

@@ -374,7 +374,11 @@ class SubstreamPartitionRouter(PartitionRouter):
         # Ignore per-partition states or invalid formats.
         if isinstance(substream_state, (list, dict)) or len(substream_state_values) != 1:
             # If a global state is present under the key "state", use its first value.
-            if "state" in stream_state and isinstance(stream_state["state"], dict):
+            if (
+                "state" in stream_state
+                and isinstance(stream_state["state"], dict)
+                and stream_state["state"] != {}
+            ):
                 substream_state = list(stream_state["state"].values())[0]
             else:
                 return {}

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

@@ -0,0 +1,13 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.properties_from_endpoint import (
+    PropertiesFromEndpoint,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.property_chunking import (
+    PropertyChunking,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.query_properties import (
+    QueryProperties,
+)
+
+__all__ = ["PropertiesFromEndpoint", "PropertyChunking", "QueryProperties"]

airbyte_cdk/sources/declarative/requesters/query_properties/properties_from_endpoint.py

@@ -0,0 +1,40 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Iterable, List, Mapping, Optional
+
+import dpath
+
+from airbyte_cdk.sources.declarative.interpolation import InterpolatedString
+from airbyte_cdk.sources.declarative.retrievers import Retriever
+from airbyte_cdk.sources.types import Config, StreamSlice
+
+
+@dataclass
+class PropertiesFromEndpoint:
+    """
+    Component that defines the behavior around how to dynamically retrieve a set of request properties from an
+    API endpoint. The set retrieved can then be injected into the requests to extract records from an API source.
+    """
+
+    property_field_path: List[str]
+    retriever: Retriever
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._property_field_path = [
+            InterpolatedString(string=property_field, parameters=parameters)
+            for property_field in self.property_field_path
+        ]
+
+    def get_properties_from_endpoint(self, stream_slice: Optional[StreamSlice]) -> Iterable[str]:
+        response_properties = self.retriever.read_records(
+            records_schema={}, stream_slice=stream_slice
+        )
+        for property_obj in response_properties:
+            path = [
+                node.eval(self.config) if not isinstance(node, str) else node
+                for node in self._property_field_path
+            ]
+            yield dpath.get(property_obj, path, default=[])  # type: ignore # extracted will be a MutableMapping, given input data structure

airbyte_cdk/sources/declarative/requesters/query_properties/property_chunking.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from enum import Enum
+from typing import Any, Iterable, List, Mapping, Optional
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies import GroupByKey
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.merge_strategy import (
+    RecordMergeStrategy,
+)
+from airbyte_cdk.sources.types import Config, Record
+
+
+class PropertyLimitType(Enum):
+    """
+    The heuristic that determines when the maximum size of the current chunk of properties and when a new
+    one should be started.
+    """
+
+    characters = "characters"
+    property_count = "property_count"
+
+
+@dataclass
+class PropertyChunking:
+    """
+    Defines the behavior for how the complete list of properties to query for are broken down into smaller groups
+    that will be used for multiple requests to the target API.
+    """
+
+    property_limit_type: PropertyLimitType
+    property_limit: Optional[int]
+    record_merge_strategy: Optional[RecordMergeStrategy]
+    parameters: InitVar[Mapping[str, Any]]
+    config: Config
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._record_merge_strategy = self.record_merge_strategy or GroupByKey(
+            key="id", config=self.config, parameters=parameters
+        )
+
+    def get_request_property_chunks(
+        self, property_fields: Iterable[str], always_include_properties: Optional[List[str]]
+    ) -> Iterable[List[str]]:
+        if not self.property_limit:
+            single_property_chunk = list(property_fields)
+            if always_include_properties:
+                single_property_chunk.extend(always_include_properties)
+            yield single_property_chunk
+            return
+        current_chunk = list(always_include_properties) if always_include_properties else []
+        chunk_size = 0
+        for property_field in property_fields:
+            # If property_limit_type is not defined, we default to property_count which is just an incrementing count
+            property_field_size = (
+                len(property_field)
+                if self.property_limit_type == PropertyLimitType.characters
+                else 1
+            )
+            if chunk_size + property_field_size > self.property_limit:
+                yield current_chunk
+                current_chunk = list(always_include_properties) if always_include_properties else []
+                chunk_size = 0
+            current_chunk.append(property_field)
+            chunk_size += property_field_size
+        yield current_chunk
+
+    def get_merge_key(self, record: Record) -> Optional[str]:
+        return self._record_merge_strategy.get_group_key(record=record)

airbyte_cdk/sources/declarative/requesters/query_properties/query_properties.py

@@ -0,0 +1,58 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Iterable, List, Mapping, Optional, Union
+
+from airbyte_cdk.sources.declarative.requesters.query_properties import (
+    PropertiesFromEndpoint,
+    PropertyChunking,
+)
+from airbyte_cdk.sources.types import Config, StreamSlice
+
+
+@dataclass
+class QueryProperties:
+    """
+    Low-code component that encompasses the behavior to inject additional property values into the outbound API
+    requests. Property values can be defined statically within the manifest or dynamically by making requests
+    to a partner API to retrieve the properties. Query properties also allow for splitting of the total set of
+    properties into smaller chunks to satisfy API restrictions around the total amount of data retrieved
+    """
+
+    property_list: Optional[Union[List[str], PropertiesFromEndpoint]]
+    always_include_properties: Optional[List[str]]
+    property_chunking: Optional[PropertyChunking]
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+
+    def get_request_property_chunks(
+        self, stream_slice: Optional[StreamSlice] = None
+    ) -> Iterable[List[str]]:
+        """
+        Uses the defined property_list to fetch the total set of properties dynamically or from a static list
+        and based on the resulting properties, performs property chunking if applicable.
+        :param stream_slice: The StreamSlice of the current partition being processed during the sync. This is included
+        because subcomponents of QueryProperties can make use of interpolation of the top-level StreamSlice object
+        """
+        fields: Union[Iterable[str], List[str]]
+        if isinstance(self.property_list, PropertiesFromEndpoint):
+            fields = self.property_list.get_properties_from_endpoint(stream_slice=stream_slice)
+        else:
+            fields = self.property_list if self.property_list else []
+
+        if self.property_chunking:
+            yield from self.property_chunking.get_request_property_chunks(
+                property_fields=fields, always_include_properties=self.always_include_properties
+            )
+        else:
+            yield list(fields)
+
+    # delete later, but leaving this to keep the discussion thread on the PR from getting hidden
+    def has_multiple_chunks(self, stream_slice: Optional[StreamSlice]) -> bool:
+        property_chunks = iter(self.get_request_property_chunks(stream_slice=stream_slice))
+        try:
+            next(property_chunks)
+            next(property_chunks)
+            return True
+        except StopIteration:
+            return False

airbyte_cdk/sources/declarative/requesters/query_properties/strategies/__init__.py

@@ -0,0 +1,10 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.group_by_key import (
+    GroupByKey,
+)
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.merge_strategy import (
+    RecordMergeStrategy,
+)
+
+__all__ = ["GroupByKey", "RecordMergeStrategy"]

airbyte_cdk/sources/declarative/requesters/query_properties/strategies/group_by_key.py

@@ -0,0 +1,33 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from dataclasses import InitVar, dataclass
+from typing import Any, List, Mapping, Optional, Union
+
+from airbyte_cdk.sources.declarative.requesters.query_properties.strategies.merge_strategy import (
+    RecordMergeStrategy,
+)
+from airbyte_cdk.sources.types import Config, Record
+
+
+@dataclass
+class GroupByKey(RecordMergeStrategy):
+    """
+    Record merge strategy that combines records together according to values on the record for one or many keys.
+    """
+
+    key: Union[str, List[str]]
+    parameters: InitVar[Mapping[str, Any]]
+    config: Config
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._keys = [self.key] if isinstance(self.key, str) else self.key
+
+    def get_group_key(self, record: Record) -> Optional[str]:
+        resolved_keys = []
+        for key in self._keys:
+            key_value = record.data.get(key)
+            if key_value:
+                resolved_keys.append(key_value)
+            else:
+                return None
+        return ",".join(resolved_keys)

airbyte_cdk/sources/declarative/requesters/query_properties/strategies/merge_strategy.py

@@ -0,0 +1,19 @@
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
+
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from typing import Optional
+
+from airbyte_cdk.sources.types import Record
+
+
+@dataclass
+class RecordMergeStrategy(ABC):
+    """
+    Describe the interface for how records that required multiple requests to get the complete set of fields
+    should be merged back into a single record.
+    """
+
+    @abstractmethod
+    def get_group_key(self, record: Record) -> Optional[str]:
+        pass

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

@@ -1,9 +1,9 @@
 #
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2025 Airbyte, Inc., all rights reserved.
 #
 
 from dataclasses import InitVar, dataclass, field
-from typing import Any, Mapping, MutableMapping, Optional, Union
+from typing import Any, List, 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,6 +40,7 @@ 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:
@@ -83,6 +84,28 @@ 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,8 +1,9 @@
 #
-# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+# Copyright (c) 2025 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
@@ -12,6 +13,7 @@ from typing import (
     Iterable,
     List,
     Mapping,
+    MutableMapping,
     Optional,
     Set,
     Tuple,
@@ -31,6 +33,7 @@ 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,
@@ -88,6 +91,7 @@ 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)
@@ -445,43 +449,110 @@ class SimpleRetriever(Retriever):
         :param stream_slice: The stream slice to read data for
         :return: The records read from the API source
         """
-        _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,
+        property_chunks = (
+            list(
+                self.additional_query_properties.get_request_property_chunks(
+                    stream_slice=stream_slice
+                )
+            )
+            if self.additional_query_properties
+            else []
         )
+        records_without_merge_key = []
+        merged_records: MutableMapping[str, Any] = defaultdict(dict)
 
-        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
+        _slice = stream_slice or StreamSlice(partition={}, cursor_slice={})  # None-check
+        most_recent_record_from_slice = None
 
-            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
+        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,
                 )
-                yield stream_data
 
+                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
+                    )
+
+                    if current_record and self.additional_query_properties.property_chunking:
+                        merge_key = (
+                            self.additional_query_properties.property_chunking.get_merge_key(
+                                current_record
+                            )
+                        )
+                        if merge_key:
+                            merged_records[merge_key].update(current_record)
+                        else:
+                            # We should still emit records even if the record did not have a merge key
+                            records_without_merge_key.append(current_record)
+                    else:
+                        yield stream_data
             if self.cursor:
                 self.cursor.close_slice(_slice, most_recent_record_from_slice)
-        return
+
+            if len(merged_records) > 0:
+                yield from [
+                    Record(data=merged_record, stream_name=self.name, associated_slice=stream_slice)
+                    for merged_record in merged_records.values()
+                ]
+            if len(records_without_merge_key) > 0:
+                yield from records_without_merge_key
+        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
+
+                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
 
     def _get_most_recent_record(
         self,

airbyte_cdk/sources/declarative/schema/default_schema_loader.py

@@ -37,7 +37,7 @@ class DefaultSchemaLoader(SchemaLoader):
 
         try:
             return self.default_loader.get_json_schema()
-        except OSError:
+        except (OSError, ValueError):
             # A slight hack since we don't directly have the stream name. However, when building the default filepath we assume the
             # runtime options stores stream name 'name' so we'll do the same here
             stream_name = self._parameters.get("name", "")

airbyte_cdk/sources/declarative/stream_slicers/declarative_partition_generator.py

@@ -58,16 +58,11 @@ class DeclarativePartition(Partition):
     def read(self) -> Iterable[Record]:
         for stream_data in self._retriever.read_records(self._json_schema, self._stream_slice):
             if isinstance(stream_data, Mapping):
-                record = (
-                    stream_data
-                    if isinstance(stream_data, Record)
-                    else Record(
-                        data=stream_data,
-                        stream_name=self.stream_name(),
-                        associated_slice=self._stream_slice,
-                    )
+                yield Record(
+                    data=stream_data,
+                    stream_name=self.stream_name(),
+                    associated_slice=self._stream_slice,
                 )
-                yield record
             else:
                 self._message_repository.emit_message(stream_data)