airbyte-cdk 0.0.0.dev0__py3-none-any.whl

airbyte_cdk/sources/declarative/schema/__init__.py

@@ -0,0 +1,25 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from airbyte_cdk.sources.declarative.schema.default_schema_loader import DefaultSchemaLoader
+from airbyte_cdk.sources.declarative.schema.dynamic_schema_loader import (
+    ComplexFieldType,
+    DynamicSchemaLoader,
+    SchemaTypeIdentifier,
+    TypesMap,
+)
+from airbyte_cdk.sources.declarative.schema.inline_schema_loader import InlineSchemaLoader
+from airbyte_cdk.sources.declarative.schema.json_file_schema_loader import JsonFileSchemaLoader
+from airbyte_cdk.sources.declarative.schema.schema_loader import SchemaLoader
+
+__all__ = [
+    "JsonFileSchemaLoader",
+    "DefaultSchemaLoader",
+    "SchemaLoader",
+    "InlineSchemaLoader",
+    "DynamicSchemaLoader",
+    "ComplexFieldType",
+    "TypesMap",
+    "SchemaTypeIdentifier",
+]

airbyte_cdk/sources/declarative/schema/default_schema_loader.py

@@ -0,0 +1,47 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+import logging
+from dataclasses import InitVar, dataclass
+from typing import Any, Mapping
+
+from airbyte_cdk.sources.declarative.schema.json_file_schema_loader import JsonFileSchemaLoader
+from airbyte_cdk.sources.declarative.schema.schema_loader import SchemaLoader
+from airbyte_cdk.sources.types import Config
+
+
+@dataclass
+class DefaultSchemaLoader(SchemaLoader):
+    """
+    Loads a schema from the default location or returns an empty schema for streams that have not defined their schema file yet.
+
+    Attributes:
+        config (Config): The user-provided configuration as specified by the source's spec
+        parameters (Mapping[str, Any]): Additional arguments to pass to the string interpolation if needed
+    """
+
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self._parameters = parameters
+        self.default_loader = JsonFileSchemaLoader(parameters=parameters, config=self.config)
+
+    def get_json_schema(self) -> Mapping[str, Any]:
+        """
+        Attempts to retrieve a schema from the default filepath location or returns the empty schema if a schema cannot be found.
+
+        :return: The empty schema
+        """
+
+        try:
+            return self.default_loader.get_json_schema()
+        except OSError:
+            # 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", "")
+            logging.info(
+                f"Could not find schema for stream {stream_name}, defaulting to the empty schema"
+            )
+            return {}

airbyte_cdk/sources/declarative/schema/dynamic_schema_loader.py

@@ -0,0 +1,285 @@
+#
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+#
+
+
+from copy import deepcopy
+from dataclasses import InitVar, dataclass, field
+from typing import Any, List, Mapping, MutableMapping, Optional, Union
+
+import dpath
+from typing_extensions import deprecated
+
+from airbyte_cdk.sources.declarative.interpolation.interpolated_boolean import InterpolatedBoolean
+from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
+from airbyte_cdk.sources.declarative.retrievers.retriever import Retriever
+from airbyte_cdk.sources.declarative.schema.schema_loader import SchemaLoader
+from airbyte_cdk.sources.declarative.transformations import RecordTransformation
+from airbyte_cdk.sources.source import ExperimentalClassWarning
+from airbyte_cdk.sources.types import Config, StreamSlice, StreamState
+
+AIRBYTE_DATA_TYPES: Mapping[str, MutableMapping[str, Any]] = {
+    "string": {"type": ["null", "string"]},
+    "boolean": {"type": ["null", "boolean"]},
+    "date": {"type": ["null", "string"], "format": "date"},
+    "timestamp_without_timezone": {
+        "type": ["null", "string"],
+        "format": "date-time",
+        "airbyte_type": "timestamp_without_timezone",
+    },
+    "timestamp_with_timezone": {"type": ["null", "string"], "format": "date-time"},
+    "time_without_timezone": {
+        "type": ["null", "string"],
+        "format": "time",
+        "airbyte_type": "time_without_timezone",
+    },
+    "time_with_timezone": {
+        "type": ["null", "string"],
+        "format": "time",
+        "airbyte_type": "time_with_timezone",
+    },
+    "integer": {"type": ["null", "integer"]},
+    "number": {"type": ["null", "number"]},
+    "array": {"type": ["null", "array"]},
+    "object": {"type": ["null", "object"]},
+}
+
+
+@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@dataclass(frozen=True)
+class ComplexFieldType:
+    """
+    Identifies complex field type
+    """
+
+    field_type: str
+    items: Optional[Union[str, "ComplexFieldType"]] = None
+
+    def __post_init__(self) -> None:
+        """
+        Enforces that `items` is only used when `field_type` is a array
+        """
+        # `items_type` is valid only for array target types
+        if self.items and self.field_type != "array":
+            raise ValueError("'items' can only be used when 'field_type' is an array.")
+
+
+@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@dataclass(frozen=True)
+class TypesMap:
+    """
+    Represents a mapping between a current type and its corresponding target type.
+    """
+
+    target_type: Union[List[str], str, ComplexFieldType]
+    current_type: Union[List[str], str]
+    condition: Optional[str]
+
+
+@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@dataclass
+class SchemaTypeIdentifier:
+    """
+    Identifies schema details for dynamic schema extraction and processing.
+    """
+
+    key_pointer: List[Union[InterpolatedString, str]]
+    parameters: InitVar[Mapping[str, Any]]
+    type_pointer: Optional[List[Union[InterpolatedString, str]]] = None
+    types_mapping: Optional[List[TypesMap]] = None
+    schema_pointer: Optional[List[Union[InterpolatedString, str]]] = None
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        self.schema_pointer = (
+            self._update_pointer(self.schema_pointer, parameters) if self.schema_pointer else []
+        )  # type: ignore[assignment]  # This is reqired field in model
+        self.key_pointer = self._update_pointer(self.key_pointer, parameters)  # type: ignore[assignment]  # This is reqired field in model
+        self.type_pointer = (
+            self._update_pointer(self.type_pointer, parameters) if self.type_pointer else None
+        )
+
+    @staticmethod
+    def _update_pointer(
+        pointer: Optional[List[Union[InterpolatedString, str]]], parameters: Mapping[str, Any]
+    ) -> Optional[List[Union[InterpolatedString, str]]]:
+        return (
+            [
+                InterpolatedString.create(path, parameters=parameters)
+                if isinstance(path, str)
+                else path
+                for path in pointer
+            ]
+            if pointer
+            else None
+        )
+
+
+@deprecated("This class is experimental. Use at your own risk.", category=ExperimentalClassWarning)
+@dataclass
+class DynamicSchemaLoader(SchemaLoader):
+    """
+    Dynamically loads a JSON Schema by extracting data from retrieved records.
+    """
+
+    retriever: Retriever
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+    schema_type_identifier: SchemaTypeIdentifier
+    schema_transformations: List[RecordTransformation] = field(default_factory=lambda: [])
+
+    def get_json_schema(self) -> Mapping[str, Any]:
+        """
+        Constructs a JSON Schema based on retrieved data.
+        """
+        properties = {}
+        retrieved_record = next(self.retriever.read_records({}), None)  # type: ignore[call-overload] # read_records return Iterable data type
+
+        raw_schema = (
+            self._extract_data(
+                retrieved_record,  # type: ignore[arg-type] # Expected that retrieved_record will be only Mapping[str, Any]
+                self.schema_type_identifier.schema_pointer,
+            )
+            if retrieved_record
+            else []
+        )
+
+        for property_definition in raw_schema:
+            key = self._get_key(property_definition, self.schema_type_identifier.key_pointer)
+            value = self._get_type(
+                property_definition,
+                self.schema_type_identifier.type_pointer,
+            )
+            properties[key] = value
+
+        transformed_properties = self._transform(properties, {})
+
+        return {
+            "$schema": "https://json-schema.org/draft-07/schema#",
+            "type": "object",
+            "additionalProperties": True,
+            "properties": transformed_properties,
+        }
+
+    def _transform(
+        self,
+        properties: Mapping[str, Any],
+        stream_state: StreamState,
+        stream_slice: Optional[StreamSlice] = None,
+    ) -> Mapping[str, Any]:
+        for transformation in self.schema_transformations:
+            transformation.transform(
+                properties,  # type: ignore  # properties has type Mapping[str, Any], but Dict[str, Any] expected
+                config=self.config,
+            )
+        return properties
+
+    def _get_key(
+        self,
+        raw_schema: MutableMapping[str, Any],
+        field_key_path: List[Union[InterpolatedString, str]],
+    ) -> str:
+        """
+        Extracts the key field from the schema using the specified path.
+        """
+        field_key = self._extract_data(raw_schema, field_key_path)
+        if not isinstance(field_key, str):
+            raise ValueError(f"Expected key to be a string. Got {field_key}")
+        return field_key
+
+    def _get_type(
+        self,
+        raw_schema: MutableMapping[str, Any],
+        field_type_path: Optional[List[Union[InterpolatedString, str]]],
+    ) -> Union[Mapping[str, Any], List[Mapping[str, Any]]]:
+        """
+        Determines the JSON Schema type for a field, supporting nullable and combined types.
+        """
+        raw_field_type = (
+            self._extract_data(raw_schema, field_type_path, default="string")
+            if field_type_path
+            else "string"
+        )
+        mapped_field_type = self._replace_type_if_not_valid(raw_field_type, raw_schema)
+        if (
+            isinstance(mapped_field_type, list)
+            and len(mapped_field_type) == 2
+            and all(isinstance(item, str) for item in mapped_field_type)
+        ):
+            first_type = self._get_airbyte_type(mapped_field_type[0])
+            second_type = self._get_airbyte_type(mapped_field_type[1])
+            return {"oneOf": [first_type, second_type]}
+
+        elif isinstance(mapped_field_type, str):
+            return self._get_airbyte_type(mapped_field_type)
+
+        elif isinstance(mapped_field_type, ComplexFieldType):
+            return self._resolve_complex_type(mapped_field_type)
+
+        else:
+            raise ValueError(
+                f"Invalid data type. Available string or two items list of string. Got {mapped_field_type}."
+            )
+
+    def _resolve_complex_type(self, complex_type: ComplexFieldType) -> Mapping[str, Any]:
+        if not complex_type.items:
+            return self._get_airbyte_type(complex_type.field_type)
+
+        field_type = self._get_airbyte_type(complex_type.field_type)
+
+        field_type["items"] = (
+            self._get_airbyte_type(complex_type.items)
+            if isinstance(complex_type.items, str)
+            else self._resolve_complex_type(complex_type.items)
+        )
+
+        return field_type
+
+    def _replace_type_if_not_valid(
+        self,
+        field_type: Union[List[str], str],
+        raw_schema: MutableMapping[str, Any],
+    ) -> Union[List[str], str, ComplexFieldType]:
+        """
+        Replaces a field type if it matches a type mapping in `types_map`.
+        """
+        if self.schema_type_identifier.types_mapping:
+            for types_map in self.schema_type_identifier.types_mapping:
+                # conditional is optional param, setting to true if not provided
+                condition = InterpolatedBoolean(
+                    condition=types_map.condition if types_map.condition is not None else "True",
+                    parameters={},
+                ).eval(config=self.config, raw_schema=raw_schema)
+
+                if field_type == types_map.current_type and condition:
+                    return types_map.target_type
+        return field_type
+
+    @staticmethod
+    def _get_airbyte_type(field_type: str) -> MutableMapping[str, Any]:
+        """
+        Maps a field type to its corresponding Airbyte type definition.
+        """
+        if field_type not in AIRBYTE_DATA_TYPES:
+            raise ValueError(f"Invalid Airbyte data type: {field_type}")
+
+        return deepcopy(AIRBYTE_DATA_TYPES[field_type])
+
+    def _extract_data(
+        self,
+        body: Mapping[str, Any],
+        extraction_path: Optional[List[Union[InterpolatedString, str]]] = None,
+        default: Any = None,
+    ) -> Any:
+        """
+        Extracts data from the body based on the provided extraction path.
+        """
+
+        if not extraction_path:
+            return body
+
+        path = [
+            node.eval(self.config) if not isinstance(node, str) else node
+            for node in extraction_path
+        ]
+
+        return dpath.get(body, path, default=default)  # type: ignore # extracted will be a MutableMapping, given input data structure

airbyte_cdk/sources/declarative/schema/inline_schema_loader.py

@@ -0,0 +1,19 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Dict, Mapping
+
+from airbyte_cdk.sources.declarative.schema.schema_loader import SchemaLoader
+
+
+@dataclass
+class InlineSchemaLoader(SchemaLoader):
+    """Describes a stream's schema"""
+
+    schema: Dict[str, Any]
+    parameters: InitVar[Mapping[str, Any]]
+
+    def get_json_schema(self) -> Mapping[str, Any]:
+        return self.schema

airbyte_cdk/sources/declarative/schema/json_file_schema_loader.py

@@ -0,0 +1,92 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+import json
+import pkgutil
+import sys
+from dataclasses import InitVar, dataclass, field
+from typing import Any, Mapping, Tuple, Union
+
+from airbyte_cdk.sources.declarative.interpolation.interpolated_string import InterpolatedString
+from airbyte_cdk.sources.declarative.schema.schema_loader import SchemaLoader
+from airbyte_cdk.sources.types import Config
+from airbyte_cdk.sources.utils.schema_helpers import ResourceSchemaLoader
+
+
+def _default_file_path() -> str:
+    # Schema files are always in "source_<connector_name>/schemas/<stream_name>.json
+    # The connector's module name can be inferred by looking at the modules loaded and look for the one starting with source_
+    source_modules = [
+        k for k, v in sys.modules.items() if "source_" in k and "airbyte_cdk" not in k
+    ]  # example: ['source_exchange_rates', 'source_exchange_rates.source']
+    if source_modules:
+        module = source_modules[0].split(".")[0]
+        return f"./{module}/schemas/{{{{parameters['name']}}}}.json"
+
+    # If we are not in a source_ module, the most likely scenario is we're processing a manifest from the connector builder
+    # server which does not require a json schema to be defined.
+    return "./{{parameters['name']}}.json"
+
+
+@dataclass
+class JsonFileSchemaLoader(ResourceSchemaLoader, SchemaLoader):
+    """
+    Loads the schema from a json file
+
+    Attributes:
+        file_path (Union[InterpolatedString, str]): The path to the json file describing the schema
+        name (str): The stream's name
+        config (Config): The user-provided configuration as specified by the source's spec
+        parameters (Mapping[str, Any]): Additional arguments to pass to the string interpolation if needed
+    """
+
+    config: Config
+    parameters: InitVar[Mapping[str, Any]]
+    file_path: Union[InterpolatedString, str] = field(default="")
+
+    def __post_init__(self, parameters: Mapping[str, Any]) -> None:
+        if not self.file_path:
+            self.file_path = _default_file_path()
+        self.file_path = InterpolatedString.create(self.file_path, parameters=parameters)
+
+    def get_json_schema(self) -> Mapping[str, Any]:
+        # todo: It is worth revisiting if we can replace file_path with just file_name if every schema is in the /schemas directory
+        # this would require that we find a creative solution to store or retrieve source_name in here since the files are mounted there
+        json_schema_path = self._get_json_filepath()
+        resource, schema_path = self.extract_resource_and_schema_path(json_schema_path)
+        raw_json_file = pkgutil.get_data(resource, schema_path)
+
+        if not raw_json_file:
+            raise IOError(f"Cannot find file {json_schema_path}")
+        try:
+            raw_schema = json.loads(raw_json_file)
+        except ValueError as err:
+            raise RuntimeError(f"Invalid JSON file format for file {json_schema_path}") from err
+        self.package_name = resource
+        return self._resolve_schema_references(raw_schema)
+
+    def _get_json_filepath(self) -> Any:
+        return self.file_path.eval(self.config)  # type: ignore # file_path is always cast to an interpolated string
+
+    @staticmethod
+    def extract_resource_and_schema_path(json_schema_path: str) -> Tuple[str, str]:
+        """
+        When the connector is running on a docker container, package_data is accessible from the resource (source_<name>), so we extract
+        the resource from the first part of the schema path and the remaining path is used to find the schema file. This is a slight
+        hack to identify the source name while we are in the airbyte_cdk module.
+        :param json_schema_path: The path to the schema JSON file
+        :return: Tuple of the resource name and the path to the schema file
+        """
+        split_path = json_schema_path.split("/")
+
+        if split_path[0] == "" or split_path[0] == ".":
+            split_path = split_path[1:]
+
+        if len(split_path) == 0:
+            return "", ""
+
+        if len(split_path) == 1:
+            return "", split_path[0]
+
+        return split_path[0], "/".join(split_path[1:])

airbyte_cdk/sources/declarative/schema/schema_loader.py

@@ -0,0 +1,17 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from abc import abstractmethod
+from dataclasses import dataclass
+from typing import Any, Mapping
+
+
+@dataclass
+class SchemaLoader:
+    """Describes a stream's schema"""
+
+    @abstractmethod
+    def get_json_schema(self) -> Mapping[str, Any]:
+        """Returns a mapping describing the stream's schema"""
+        pass

airbyte_cdk/sources/declarative/spec/__init__.py

@@ -0,0 +1,7 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from airbyte_cdk.sources.declarative.spec.spec import Spec
+
+__all__ = ["Spec"]

airbyte_cdk/sources/declarative/spec/spec.py

@@ -0,0 +1,48 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from dataclasses import InitVar, dataclass
+from typing import Any, Mapping, Optional
+
+from airbyte_cdk.models import (
+    AdvancedAuth,
+    ConnectorSpecification,
+    ConnectorSpecificationSerializer,
+)
+from airbyte_cdk.sources.declarative.models.declarative_component_schema import AuthFlow
+
+
+@dataclass
+class Spec:
+    """
+    Returns a connection specification made up of information about the connector and how it can be configured
+
+    Attributes:
+        connection_specification (Mapping[str, Any]): information related to how a connector can be configured
+        documentation_url (Optional[str]): The link the Airbyte documentation about this connector
+    """
+
+    connection_specification: Mapping[str, Any]
+    parameters: InitVar[Mapping[str, Any]]
+    documentation_url: Optional[str] = None
+    advanced_auth: Optional[AuthFlow] = None
+
+    def generate_spec(self) -> ConnectorSpecification:
+        """
+        Returns the connector specification according the spec block defined in the low code connector manifest.
+        """
+
+        obj: dict[str, Mapping[str, Any] | str | AdvancedAuth] = {
+            "connectionSpecification": self.connection_specification
+        }
+
+        if self.documentation_url:
+            obj["documentationUrl"] = self.documentation_url
+        if self.advanced_auth:
+            self.advanced_auth.auth_flow_type = self.advanced_auth.auth_flow_type.value  # type: ignore # We know this is always assigned to an AuthFlow which has the auth_flow_type field
+            # Map CDK AuthFlow model to protocol AdvancedAuth model
+            obj["advanced_auth"] = self.advanced_auth.dict()
+
+        # We remap these keys to camel case because that's the existing format expected by the rest of the platform
+        return ConnectorSpecificationSerializer.load(obj)

airbyte_cdk/sources/declarative/stream_slicers/__init__.py

@@ -0,0 +1,7 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from airbyte_cdk.sources.declarative.stream_slicers.stream_slicer import StreamSlicer
+
+__all__ = ["StreamSlicer"]

airbyte_cdk/sources/declarative/stream_slicers/declarative_partition_generator.py

@@ -0,0 +1,93 @@
+# Copyright (c) 2024 Airbyte, Inc., all rights reserved.
+
+from typing import Any, Iterable, Mapping, Optional
+
+from airbyte_cdk.sources.declarative.retrievers import Retriever
+from airbyte_cdk.sources.message import MessageRepository
+from airbyte_cdk.sources.streams.concurrent.partitions.partition import Partition
+from airbyte_cdk.sources.streams.concurrent.partitions.partition_generator import PartitionGenerator
+from airbyte_cdk.sources.streams.concurrent.partitions.stream_slicer import StreamSlicer
+from airbyte_cdk.sources.types import Record, StreamSlice
+from airbyte_cdk.utils.slice_hasher import SliceHasher
+
+
+class DeclarativePartitionFactory:
+    def __init__(
+        self,
+        stream_name: str,
+        json_schema: Mapping[str, Any],
+        retriever: Retriever,
+        message_repository: MessageRepository,
+    ) -> None:
+        """
+        The DeclarativePartitionFactory takes a retriever_factory and not a retriever directly. The reason is that our components are not
+        thread safe and classes like `DefaultPaginator` may not work because multiple threads can access and modify a shared field across each other.
+        In order to avoid these problems, we will create one retriever per thread which should make the processing thread-safe.
+        """
+        self._stream_name = stream_name
+        self._json_schema = json_schema
+        self._retriever = retriever
+        self._message_repository = message_repository
+
+    def create(self, stream_slice: StreamSlice) -> Partition:
+        return DeclarativePartition(
+            self._stream_name,
+            self._json_schema,
+            self._retriever,
+            self._message_repository,
+            stream_slice,
+        )
+
+
+class DeclarativePartition(Partition):
+    def __init__(
+        self,
+        stream_name: str,
+        json_schema: Mapping[str, Any],
+        retriever: Retriever,
+        message_repository: MessageRepository,
+        stream_slice: StreamSlice,
+    ):
+        self._stream_name = stream_name
+        self._json_schema = json_schema
+        self._retriever = retriever
+        self._message_repository = message_repository
+        self._stream_slice = stream_slice
+        self._hash = SliceHasher.hash(self._stream_name, self._stream_slice)
+
+    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
+            else:
+                self._message_repository.emit_message(stream_data)
+
+    def to_slice(self) -> Optional[Mapping[str, Any]]:
+        return self._stream_slice
+
+    def stream_name(self) -> str:
+        return self._stream_name
+
+    def __hash__(self) -> int:
+        return self._hash
+
+
+class StreamSlicerPartitionGenerator(PartitionGenerator):
+    def __init__(
+        self, partition_factory: DeclarativePartitionFactory, stream_slicer: StreamSlicer
+    ) -> None:
+        self._partition_factory = partition_factory
+        self._stream_slicer = stream_slicer
+
+    def generate(self) -> Iterable[Partition]:
+        for stream_slice in self._stream_slicer.stream_slices():
+            yield self._partition_factory.create(stream_slice)

airbyte_cdk/sources/declarative/stream_slicers/stream_slicer.py

@@ -0,0 +1,25 @@
+#
+# Copyright (c) 2023 Airbyte, Inc., all rights reserved.
+#
+
+from abc import ABC
+
+from airbyte_cdk.sources.declarative.requesters.request_options.request_options_provider import (
+    RequestOptionsProvider,
+)
+from airbyte_cdk.sources.streams.concurrent.partitions.stream_slicer import (
+    StreamSlicer as ConcurrentStreamSlicer,
+)
+
+
+class StreamSlicer(ConcurrentStreamSlicer, RequestOptionsProvider, ABC):
+    """
+    Slices the stream into a subset of records.
+    Slices enable state checkpointing and data retrieval parallelization.
+
+    The stream slicer keeps track of the cursor state as a dict of cursor_field -> cursor_value
+
+    See the stream slicing section of the docs for more information.
+    """
+
+    pass