airbyte-cdk 6.45.0__py3-none-any.whl → 6.45.0.dev4101__py3-none-any.whl

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

@@ -1,69 +0,0 @@
-# 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

@@ -1,58 +0,0 @@
-# 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

@@ -1,10 +0,0 @@
-# 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

@@ -1,33 +0,0 @@
-# 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

@@ -1,19 +0,0 @@
-# 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