omniload 0.0.0.dev0__py3-none-any.whl

omniload/src/kafka/__init__.py

@@ -0,0 +1,120 @@
+# Copyright 2022-2025 ScaleVector
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""A source to extract Kafka messages.
+
+When extraction starts, partitions length is checked -
+data is read only up to it, overriding the default Kafka's
+behavior of waiting for new messages in endless loop.
+"""
+
+from contextlib import closing
+from typing import Any, Callable, Dict, Iterable, List, Optional, Union
+
+import dlt
+from confluent_kafka import Consumer, Message  # type: ignore
+from dlt.common import logger
+from dlt.common.time import ensure_pendulum_datetime
+from dlt.common.typing import TAnyDateTime, TDataItem
+
+from .helpers import (
+    KafkaCredentials,
+    OffsetTracker,
+    default_msg_processor,
+)
+
+
+@dlt.resource(
+    name="kafka_messages",
+    table_name=lambda msg: msg["_kafka"]["topic"],
+    standalone=True,
+)
+def kafka_consumer(
+    topics: Union[str, List[str]],
+    credentials: Union[KafkaCredentials, Consumer] = dlt.secrets.value,
+    msg_processor: Optional[
+        Callable[[Message], Dict[str, Any]]
+    ] = default_msg_processor,
+    batch_size: Optional[int] = 3000,
+    batch_timeout: Optional[int] = 3,
+    start_from: Optional[TAnyDateTime] = None,
+) -> Iterable[TDataItem]:
+    """Extract recent messages from the given Kafka topics.
+
+    The resource tracks offsets for all the topics and partitions,
+    and so reads data incrementally.
+
+    Messages from different topics are saved in different tables.
+
+    Args:
+        topics (Union[str, List[str]]): Names of topics to extract.
+        credentials (Optional[Union[KafkaCredentials, Consumer]]):
+            Auth credentials or an initiated Kafka consumer. By default,
+            is taken from secrets.
+        msg_processor(Optional[Callable]): A function-converter,
+            which'll process every Kafka message after it's read and
+            before it's transfered to the destination.
+        batch_size (Optional[int]): Messages batch size to read at once.
+        batch_timeout (Optional[int]): Maximum time to wait for a batch
+            consume, in seconds.
+        start_from (Optional[TAnyDateTime]): A timestamp, at which to start
+            reading. Older messages are ignored.
+
+    Yields:
+        Iterable[TDataItem]: Kafka messages.
+    """
+    if not isinstance(topics, list):
+        topics = [topics]
+
+    if isinstance(credentials, Consumer):
+        consumer = credentials
+    elif isinstance(credentials, KafkaCredentials):
+        consumer = credentials.init_consumer()
+    else:
+        raise TypeError(
+            (
+                "Wrong credentials type provided. Need to be of type: "
+                "KafkaCredentials or confluent_kafka.Consumer"
+            )
+        )
+
+    if start_from is not None:
+        start_from = ensure_pendulum_datetime(start_from)
+
+    tracker = OffsetTracker(consumer, topics, dlt.current.resource_state(), start_from)  # type: ignore
+
+    # read messages up to the maximum offsets,
+    # not waiting for new messages
+    with closing(consumer):
+        while True:
+            messages = consumer.consume(batch_size, timeout=batch_timeout)
+            if not messages:
+                break
+
+            batch = []
+            for msg in messages:
+                if msg.error():
+                    err = msg.error()
+                    if err.retriable() or not err.fatal():
+                        logger.warning(f"ERROR: {err} - RETRYING")
+                    else:
+                        raise err
+                else:
+                    batch.append(msg_processor(msg))  # type: ignore
+                    tracker.renew(msg)
+
+            yield batch
+
+            if tracker.has_unread is False:
+                return

omniload/src/kafka/helpers.py

@@ -0,0 +1,241 @@
+# Copyright 2022-2025 ScaleVector
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Dict, List, Optional
+
+from confluent_kafka import Consumer, Message, TopicPartition  # type: ignore
+from confluent_kafka.admin import TopicMetadata  # type: ignore
+from dlt import config
+from dlt.common import pendulum
+from dlt.common.configuration import configspec
+from dlt.common.configuration.specs import CredentialsConfiguration
+from dlt.common.time import ensure_pendulum_datetime
+from dlt.common.typing import DictStrAny, TSecretValue
+from dlt.common.utils import digest128
+
+
+def default_msg_processor(msg: Message) -> Dict[str, Any]:
+    """Basic Kafka message processor.
+
+    Returns the message value and metadata. Timestamp consists of two values:
+    (type of the timestamp, timestamp). Type represents one of the Python
+    Kafka constants:
+        TIMESTAMP_NOT_AVAILABLE - Timestamps not supported by broker.
+        TIMESTAMP_CREATE_TIME - Message creation time (or source / producer time).
+        TIMESTAMP_LOG_APPEND_TIME - Broker receive time.
+
+    Args:
+        msg (confluent_kafka.Message): A single Kafka message.
+
+    Returns:
+        dict: Processed Kafka message.
+    """
+    ts = msg.timestamp()
+    topic = msg.topic()
+    partition = msg.partition()
+    key = msg.key()
+    if key is not None:
+        key = key.decode("utf-8")
+
+    return {
+        "_kafka": {
+            "partition": partition,
+            "topic": topic,
+            "key": key,
+            "offset": msg.offset(),
+            "ts": {
+                "type": ts[0],
+                "value": ensure_pendulum_datetime(ts[1] / 1e3),
+            },
+            "data": msg.value().decode("utf-8"),
+        },
+        "_kafka_msg_id": digest128(topic + str(partition) + str(key)),
+    }
+
+
+class OffsetTracker(dict):  # type: ignore
+    """Object to control offsets of the given topics.
+
+    Tracks all the partitions of the given topics with two params:
+    current offset and maximum offset (partition length).
+
+    Args:
+        consumer (confluent_kafka.Consumer): Kafka consumer.
+        topic_names (List): Names of topics to track.
+        pl_state (DictStrAny): Pipeline current state.
+        start_from (Optional[pendulum.DateTime]): A timestamp, after which messages
+            are read. Older messages are ignored.
+    """
+
+    def __init__(
+        self,
+        consumer: Consumer,
+        topic_names: List[str],
+        pl_state: DictStrAny,
+        start_from: pendulum.DateTime = None,  # type: ignore
+    ):
+        super().__init__()
+
+        self._consumer = consumer
+        self._topics = self._read_topics(topic_names)
+
+        # read/init current offsets
+        self._cur_offsets = pl_state.setdefault(
+            "offsets", {t_name: {} for t_name in topic_names}
+        )
+
+        self._init_partition_offsets(start_from)
+
+    def _read_topics(self, topic_names: List[str]) -> Dict[str, TopicMetadata]:
+        """Read the given topics metadata from Kafka.
+
+        Reads all the topics at once, instead of requesting
+        each in a separate call. Returns only those needed.
+
+        Args:
+            topic_names (list): Names of topics to be read.
+
+        Returns:
+            dict: Metadata of the given topics.
+        """
+        tracked_topics = {}
+        topics = self._consumer.list_topics().topics
+
+        for t_name in topic_names:
+            tracked_topics[t_name] = topics[t_name]
+
+        return tracked_topics
+
+    def _init_partition_offsets(self, start_from: pendulum.DateTime) -> None:
+        """Designate current and maximum offsets for every partition.
+
+        Current offsets are read from the state, if present. Set equal
+        to the partition beginning otherwise.
+
+        Args:
+            start_from (pendulum.DateTime): A timestamp, at which to start
+                reading. Older messages are ignored.
+        """
+        all_parts = []
+        for t_name, topic in self._topics.items():
+            self[t_name] = {}
+
+            # init all the topic partitions from the partitions' metadata
+            parts = [
+                TopicPartition(
+                    t_name,
+                    part,
+                    start_from.int_timestamp * 1000 if start_from is not None else 0,
+                )
+                for part in topic.partitions
+            ]
+
+            # get offsets for the timestamp, if given
+            if start_from is not None:
+                ts_offsets = self._consumer.offsets_for_times(parts)
+
+            # designate current and maximum offsets for every partition
+            for i, part in enumerate(parts):
+                max_offset = self._consumer.get_watermark_offsets(part)[1]
+
+                if start_from is not None:
+                    if ts_offsets[i].offset != -1:
+                        cur_offset = ts_offsets[i].offset
+                    else:
+                        cur_offset = max_offset - 1
+                else:
+                    cur_offset = (
+                        self._cur_offsets[t_name].get(str(part.partition), -1) + 1
+                    )
+
+                self[t_name][str(part.partition)] = {
+                    "cur": cur_offset,
+                    "max": max_offset,
+                }
+
+                parts[i].offset = cur_offset
+
+            all_parts += parts
+
+        # assign the current offsets to the consumer
+        self._consumer.assign(all_parts)
+
+    @property
+    def has_unread(self) -> bool:
+        """Check if there are unread messages in the tracked topics.
+
+        Returns:
+            bool: True, if there are messages to read, False if all
+                the current offsets are equal to their maximums.
+        """
+        for parts in self.values():
+            for part in parts.values():
+                if part["cur"] + 1 < part["max"]:
+                    return True
+
+        return False
+
+    def renew(self, msg: Message) -> None:
+        """Update partition offset from the given message.
+
+        Args:
+            msg (confluent_kafka.Message): A read Kafka message.
+        """
+        topic = msg.topic()
+        partition = str(msg.partition())
+
+        offset = self[topic][partition]
+        offset["cur"] = msg.offset()
+
+        self._cur_offsets[topic][partition] = msg.offset()
+
+
+@configspec
+class KafkaCredentials(CredentialsConfiguration):
+    """Kafka source credentials.
+
+    NOTE: original Kafka credentials are written with a period, e.g.
+    bootstrap.servers. However, KafkaCredentials expect them to
+    use underscore symbols instead, e.g. bootstrap_servers.
+    """
+
+    bootstrap_servers: str = config.value
+    group_id: str = config.value
+    security_protocol: Optional[str] = None
+    sasl_mechanisms: Optional[str] = None
+    sasl_username: Optional[str] = None
+    sasl_password: Optional[TSecretValue] = None
+
+    def init_consumer(self) -> Consumer:
+        """Init a Kafka consumer from this credentials.
+
+        Returns:
+            confluent_kafka.Consumer: an initiated consumer.
+        """
+        config = {
+            "bootstrap.servers": self.bootstrap_servers,
+            "group.id": self.group_id,
+            "auto.offset.reset": "earliest",
+        }
+
+        if self.security_protocol:
+            config["security.protocol"] = self.security_protocol
+        if self.sasl_mechanisms:
+            config["sasl.mechanisms"] = self.sasl_mechanisms
+        if self.sasl_username:
+            config["sasl.username"] = self.sasl_username
+        if self.sasl_password:
+            config["sasl.password"] = self.sasl_password
+
+        return Consumer(config)

omniload/src/kinesis/__init__.py

@@ -0,0 +1,153 @@
+# Copyright 2022-2025 ScaleVector
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Reads messages from Kinesis queue."""
+
+from typing import Iterable, List, Optional
+
+import dlt
+from dlt.common import json, pendulum
+from dlt.common.configuration.specs import AwsCredentials
+from dlt.common.time import ensure_pendulum_datetime
+from dlt.common.typing import StrStr, TAnyDateTime, TDataItem
+from dlt.common.utils import digest128
+
+from .helpers import get_shard_iterator, get_stream_address, max_sequence_by_shard
+
+
+@dlt.resource(
+    name=lambda args: args["stream_name"],
+    primary_key="kinesis_msg_id",
+    standalone=True,
+    max_table_nesting=0,
+)
+def kinesis_stream(
+    stream_name: str,
+    initial_at_timestamp: TAnyDateTime,
+    credentials: AwsCredentials,
+    last_msg: Optional[dlt.sources.incremental[StrStr]] = dlt.sources.incremental(
+        "kinesis", last_value_func=max_sequence_by_shard
+    ),
+    max_number_of_messages: int = None,  # type: ignore
+    milliseconds_behind_latest: int = 1000,
+    parse_json: bool = True,
+    chunk_size: int = 1000,
+) -> Iterable[TDataItem]:
+    """Reads a kinesis stream and yields messages. Supports incremental loading. Parses messages as json by default.
+
+    Args:
+        stream_name (str): The name of the stream to read from. If not provided, the
+            value must be present in config/secrets
+        credentials (AwsCredentials): The credentials to use to connect to kinesis. If not provided,
+            the value from secrets or credentials present on the device will be used.
+        last_msg (Optional[dlt.sources.incremental]): An incremental over a mapping from shard_id to message sequence
+            that will be used to create shard iterators of type AFTER_SEQUENCE_NUMBER when loading incrementally.
+        initial_at_timestamp (TAnyDateTime): An initial timestamp used to generate AT_TIMESTAMP or LATEST iterator when timestamp value is 0
+        max_number_of_messages (int): Maximum number of messages to read in one run. Actual read may exceed that number by up to chunk_size. Defaults to None (no limit).
+        milliseconds_behind_latest (int): The number of milliseconds behind the top of the shard to stop reading messages, defaults to 1000.
+        parse_json (bool): If True, assumes that messages are json strings, parses them and returns instead of `data` (otherwise). Defaults to True.
+        chunk_size (int): The number of records to fetch at once. Defaults to 1000.
+    Yields:
+            Iterable[TDataItem]: Messages. Contain Kinesis envelope in `kinesis` and bytes data in `data` (if `parse_json` disabled)
+
+    """
+    session = credentials._to_botocore_session()
+    # the default timeouts are (60, 60) which is fine
+    kinesis_client = session.create_client("kinesis")
+    # normalize at_timestamp to pendulum
+    initial_at_datetime = (
+        None
+        if initial_at_timestamp is None
+        else ensure_pendulum_datetime(initial_at_timestamp)
+    )
+    # set it in state
+    resource_state = dlt.current.resource_state()
+    initial_at_datetime = resource_state.get(
+        "initial_at_timestamp", initial_at_datetime
+    )
+    # so next time we request shards at AT_TIMESTAMP that is now
+    resource_state["initial_at_timestamp"] = pendulum.now("UTC").subtract(seconds=1)
+
+    shards_list = kinesis_client.list_shards(**get_stream_address(stream_name))
+    shards: List[StrStr] = shards_list["Shards"]
+    while next_token := shards_list.get("NextToken"):
+        shards_list = kinesis_client.list_shards(NextToken=next_token)
+        shards.extend(shards_list)
+
+    shard_ids = [shard["ShardId"] for shard in shards]
+
+    # get next shard to fetch messages from
+    while shard_id := shard_ids.pop(0) if shard_ids else None:
+        shard_iterator, _ = get_shard_iterator(
+            kinesis_client,
+            stream_name,
+            shard_id,
+            last_msg,  # type: ignore
+            initial_at_datetime,  # type: ignore
+        )
+
+        while shard_iterator:
+            records = []
+            records_response = kinesis_client.get_records(
+                ShardIterator=shard_iterator,
+                Limit=chunk_size,  # The size of data can be up to 1 MB, it must be controlled by the user
+            )
+
+            for record in records_response["Records"]:
+                sequence_number = record["SequenceNumber"]
+                content = record["Data"]
+
+                arrival_time = record["ApproximateArrivalTimestamp"]
+                arrival_timestamp = arrival_time.astimezone(pendulum.UTC)
+
+                message = {
+                    "kinesis": {
+                        "shard_id": shard_id,
+                        "seq_no": sequence_number,
+                        "ts": ensure_pendulum_datetime(arrival_timestamp),
+                        "partition": record["PartitionKey"],
+                        "stream_name": stream_name,
+                    },
+                    "kinesis_msg_id": digest128(shard_id + sequence_number),
+                }
+
+                if parse_json:
+                    message.update(json.loadb(content))
+                else:
+                    message["data"] = content
+                records.append(message)
+            yield records
+
+            # do not load more  max_number_of_messages
+            if max_number_of_messages is not None:
+                max_number_of_messages -= len(records)
+                if max_number_of_messages <= 0:
+                    return
+
+            # add child shards so we can request messages from them
+            child_shards = records_response.get("ChildShards", None)
+            if child_shards:
+                for child_shard in child_shards:
+                    child_shard_id = child_shard["ShardId"]
+                    if child_shard_id not in shards:
+                        shard_ids.append(child_shard_id)
+
+            # gets 0 when no messages so we cutoff empty shards
+            records_ms_behind_latest = records_response.get("MillisBehindLatest", 0)
+            if records_ms_behind_latest < milliseconds_behind_latest:
+                # stop taking messages from shard
+                shard_iterator = None  # type: ignore
+            else:
+                # continue taking messages
+                shard_iterator = records_response["NextShardIterator"]

omniload/src/kinesis/helpers.py

@@ -0,0 +1,96 @@
+# Copyright 2022-2025 ScaleVector
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Sequence, Tuple
+
+import dlt
+from dlt.common import pendulum
+from dlt.common.typing import DictStrAny, DictStrStr, StrAny, StrStr
+
+
+def get_shard_iterator(
+    kinesis_client: Any,
+    stream_name: str,
+    shard_id: str,
+    last_msg: dlt.sources.incremental[StrStr],
+    initial_at_timestamp: pendulum.DateTime | None,
+) -> Tuple[str, StrAny]:
+    """Gets shard `shard_id` of `stream_name` iterator. If `last_msg` incremental is present it may
+    contain last message sequence for shard_id. in that case AFTER_SEQUENCE_NUMBER is created.
+    If no message sequence is present, `initial_at_timestamp` is used for AT_TIMESTAMP or LATEST.
+    The final fallback is TRIM_HORIZON
+    """
+    sequence_state = (
+        {} if last_msg is None else last_msg.last_value or last_msg.initial_value or {}
+    )
+    iterator_params: DictStrAny
+    msg_sequence = sequence_state.get(shard_id, None)
+    if msg_sequence:
+        iterator_params = dict(
+            ShardIteratorType="AFTER_SEQUENCE_NUMBER",
+            StartingSequenceNumber=msg_sequence,
+        )
+    elif initial_at_timestamp is None:
+        # Fetch all records from the beginning
+        iterator_params = dict(ShardIteratorType="TRIM_HORIZON")
+
+    elif initial_at_timestamp.timestamp() == 0.0:
+        # will sets to latest i.e only the messages at the tip of the stream are read
+        iterator_params = dict(ShardIteratorType="LATEST")
+    else:
+        iterator_params = dict(
+            ShardIteratorType="AT_TIMESTAMP", Timestamp=initial_at_timestamp.timestamp()
+        )
+
+    shard_iterator: StrStr = kinesis_client.get_shard_iterator(
+        **get_stream_address(stream_name), ShardId=shard_id, **iterator_params
+    )
+    return shard_iterator["ShardIterator"], iterator_params
+
+
+def max_sequence_by_shard(values: Sequence[StrStr]) -> StrStr:
+    """A last_value_function that operates on mapping of shard_id:msg_sequence defining the max"""
+    last_value = None
+    # if tuple/list contains only one element then return it
+    if len(values) == 1:
+        item = values[0]
+    else:
+        # item is kinesis metadata, last_value is previous state of the shards
+        item, last_value = values
+
+    if last_value is None:
+        last_value = {}
+    else:
+        last_value = dict(last_value)  # always make a copy
+    shard_id = item["shard_id"]
+    # we compare message sequence at shard_id
+    last_value[shard_id] = max(item["seq_no"], last_value.get(shard_id, ""))
+    return last_value
+
+
+def get_stream_address(stream_name: str) -> DictStrStr:
+    """
+    Return address of stream, either as StreamName or StreamARN, when applicable.
+
+    Examples:
+    - customer_events
+    - arn:aws:kinesis:eu-central-1:842404475894:stream/customer_events
+
+    https://docs.aws.amazon.com/kinesis/latest/APIReference/API_StreamDescription.html#Streams-Type-StreamDescription-StreamName
+    https://docs.aws.amazon.com/kinesis/latest/APIReference/API_StreamDescription.html#Streams-Type-StreamDescription-StreamARN
+    """
+    if stream_name.startswith("arn:"):
+        return {"StreamARN": stream_name}
+    else:
+        return {"StreamName": stream_name}