ingestr 0.13.16__tar.gz → 0.13.17__tar.gz

{ingestr-0.13.16 → ingestr-0.13.17}/Makefile

@@ -16,8 +16,6 @@ deps:
 
 deps-ci:
 	uv pip install --system -r requirements-dev.txt
-	uv pip install --system '.[clickhouse]'
-
 
 test-ci:
 	TESTCONTAINERS_RYUK_DISABLED=true pytest -n auto -x -rP -vv --tb=short --durations=10 --cov=ingestr --no-cov-on-fail

{ingestr-0.13.16 → ingestr-0.13.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ingestr
-Version: 0.13.16
+Version: 0.13.17
 Summary: ingestr is a command-line application that ingests data from various sources and stores them in any database.
 Project-URL: Homepage, https://github.com/bruin-data/ingestr
 Project-URL: Issues, https://github.com/bruin-data/ingestr/issues
@@ -15,6 +15,9 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Database
 Requires-Python: >=3.9
 Requires-Dist: asana==3.2.3
+Requires-Dist: clickhouse-connect==0.8.14
+Requires-Dist: clickhouse-driver==0.2.9
+Requires-Dist: clickhouse-sqlalchemy==0.2.7
 Requires-Dist: confluent-kafka==2.8.0
 Requires-Dist: databricks-sql-connector==2.9.3
 Requires-Dist: databricks-sqlalchemy==1.0.2
@@ -55,11 +58,7 @@ Requires-Dist: stripe==10.7.0
 Requires-Dist: tqdm==4.67.1
 Requires-Dist: typer==0.13.1
 Requires-Dist: types-requests==2.32.0.20240907
-Provides-Extra: clickhouse
-Requires-Dist: clickhouse-connect==0.8.14; extra == 'clickhouse'
-Requires-Dist: clickhouse-driver==0.2.9; extra == 'clickhouse'
-Requires-Dist: clickhouse-sqlalchemy==0.2.7; extra == 'clickhouse'
-Requires-Dist: zstd==1.5.6.1; extra == 'clickhouse'
+Requires-Dist: zstd==1.5.6.5
 Provides-Extra: odbc
 Requires-Dist: pyodbc==5.1.0; extra == 'odbc'
 Provides-Extra: oracle
@@ -231,6 +230,11 @@ Pull requests are welcome. However, please open an issue first to discuss what y
         <td>✅</td>
         <td>-</td>
     </tr>
+    <tr>
+        <td>Amazon Kinesis</td>
+        <td>✅</td>
+        <td>-</td>
+    </tr>
     <tr>
         <td>Apache Kafka</td>
         <td>✅</td>

{ingestr-0.13.16 → ingestr-0.13.17}/README.md

@@ -163,6 +163,11 @@ Pull requests are welcome. However, please open an issue first to discuss what y
         <td>✅</td>
         <td>-</td>
     </tr>
+    <tr>
+        <td>Amazon Kinesis</td>
+        <td>✅</td>
+        <td>-</td>
+    </tr>
     <tr>
         <td>Apache Kafka</td>
         <td>✅</td>

{ingestr-0.13.16 → ingestr-0.13.17}/docs/.vitepress/config.mjs

@@ -95,6 +95,7 @@ export default defineConfig({
             items: [
               { text: "Adjust", link: "/supported-sources/adjust.md" },
               { text: "Airtable", link: "/supported-sources/airtable.md" },
+              { text: "Amazon Kinesis", link: "/supported-sources/kinesis.md" },
               { text: "AppsFlyer", link: "/supported-sources/appsflyer.md" },
               { text: "Apple App Store", link: "/supported-sources/appstore.md"},
               { text: "Applovin", link: "/supported-sources/applovin.md"},

{ingestr-0.13.16 → ingestr-0.13.17}/docs/supported-sources/clickhouse.md

@@ -2,11 +2,6 @@
 ClickHouse is a fast, open-source, column-oriented database management system that allows for high performance data ingestion and querying.
 
 ingestr supports ClickHouse as a source and destination.
-> [!INFO]
-> To use clickhouse in `ingestr` you need to install it's dependencies using:
-> ```
-> $ pip install ingestr[clickhouse]
-> ```
 
 ## URI format
 The URI format for ClickHouse as a source is as follows:

ingestr-0.13.17/docs/supported-sources/kinesis.md

@@ -0,0 +1,39 @@
+# Amazon Kinesis
+
+[Amazon Kinesis](https://docs.aws.amazon.com/streams/latest/dev/key-concepts.html) is a
+cloud-based service for real-time data streaming and analytics, enabling the processing and analysis of large streams of data in real time.
+
+ingestr supports Kinesis as a source.
+
+## URI format
+The URI format for Kinesis is as follows:
+
+```plaintext
+kinesis://?aws_access_key_id=<aws-access-key-id>&aws_secret_access_key=<aws-secret-access-key>&region_name=<region-name>
+``` 
+
+URI parameters:
+- `aws_access_key_id`: the AWS access key ID used to authenticate the request
+- `aws_secret_access_key`: the AWS secret access key used to authenticate the request
+- `region_name`: the AWS region name where the stream is located
+
+
+
+## Setting up a Kinesis Integration
+To get Kinesis credentials, please refer to the guide [here](https://dlthub.com/docs/dlt-ecosystem/verified-sources/amazon_kinesis#grab-credentials)
+
+Once you complete the guide, you should have a aws_access_key_id, aws_secret_access_key and region_name. Let's say your `aws_access_key_id` is id_123, your `aws_secret_access_key` is secret_123 and your `region_name` is eu-central-1, here's a sample command that will copy the data from Kinesis into a DuckDB database:
+
+```bash
+ingestr ingest --source-uri 'kinesis://?aws_access_key_id=id_123&aws_secret_access_key=secret_123&region_name=eu-central-1' \
+ --source-table 'stream_name_1' \
+ --dest-uri duckdb:///kinesis.duckdb \
+ --dest-table 'dest.results'
+```
+
+When using Kinesis as a source, specify the `stream name` you want to read from as the `--source-table` parameter. For example, if you want to read from a Kinesis stream named "customer_events", you would use `--source-table 'customer_events'`.
+
+### Initial Load Configuration
+By default, ingestr reads from the beginning of the Kinesis stream. To start reading from a specific time, use the `interval_start` parameter.
+
+

ingestr-0.13.17/ingestr/src/buildinfo.py

@@ -0,0 +1 @@
+version = "v0.13.17"

{ingestr-0.13.16 → ingestr-0.13.17}/ingestr/src/factory.py

@@ -36,6 +36,7 @@ from ingestr.src.sources import (
     GorgiasSource,
     HubspotSource,
     KafkaSource,
+    KinesisSource,
     KlaviyoSource,
     LinkedInAdsSource,
     LocalCsvSource,
@@ -141,6 +142,7 @@ class SourceDestinationFactory:
         "applovinmax": ApplovinMaxSource,
         "salesforce": SalesforceSource,
         "personio": PersonioSource,
+        "kinesis": KinesisSource,
     }
     destinations: Dict[str, Type[DestinationProtocol]] = {
         "bigquery": BigQueryDestination,

ingestr-0.13.17/ingestr/src/kinesis/__init__.py

@@ -0,0 +1,139 @@
+"""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, max_sequence_by_shard
+
+
+@dlt.resource(
+    name=lambda args: args["stream_name"],
+    primary_key="kinesis_msg_id",
+    standalone=True,
+)
+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 False.
+        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(StreamName=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"]

ingestr-0.13.17/ingestr/src/kinesis/helpers.py

@@ -0,0 +1,65 @@
+from typing import Any, Sequence, Tuple
+
+import dlt
+from dlt.common import pendulum
+from dlt.common.typing import DictStrAny, 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(
+        StreamName=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

{ingestr-0.13.16 → ingestr-0.13.17}/ingestr/src/sources.py

@@ -75,6 +75,7 @@ from ingestr.src.gorgias import gorgias_source
 from ingestr.src.hubspot import hubspot
 from ingestr.src.kafka import kafka_consumer
 from ingestr.src.kafka.helpers import KafkaCredentials
+from ingestr.src.kinesis import kinesis_stream
 from ingestr.src.klaviyo._init_ import klaviyo_source
 from ingestr.src.linkedin_ads import linked_in_ads_source
 from ingestr.src.linkedin_ads.dimension_time_enum import (
@@ -1969,3 +1970,39 @@ class PersonioSource:
             start_date=interval_start_date,
             end_date=interval_end_date,
         ).with_resources(table)
+
+
+class KinesisSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        # kinesis://?aws_access_key_id=<AccessKeyId>&aws_secret_access_key=<SecretAccessKey>&region_name=<Region>
+        # source table = stream name
+        parsed_uri = urlparse(uri)
+        params = parse_qs(parsed_uri.query)
+
+        aws_access_key_id = params.get("aws_access_key_id")
+        if aws_access_key_id is None:
+            raise MissingValueError("aws_access_key_id", "Kinesis")
+
+        aws_secret_access_key = params.get("aws_secret_access_key")
+        if aws_secret_access_key is None:
+            raise MissingValueError("aws_secret_access_key", "Kinesis")
+
+        region_name = params.get("region_name")
+        if region_name is None:
+            raise MissingValueError("region_name", "Kinesis")
+
+        start_date = kwargs.get("interval_start")
+        if start_date is not None:
+            # the resource will read all messages after this timestamp.
+            start_date = ensure_pendulum_datetime(start_date)
+        credentials = AwsCredentials(
+            aws_access_key_id=aws_access_key_id[0],
+            aws_secret_access_key=aws_secret_access_key[0],
+            region_name=region_name[0],
+        )
+        return kinesis_stream(
+            stream_name=table, credentials=credentials, initial_at_timestamp=start_date
+        )

{ingestr-0.13.16 → ingestr-0.13.17}/pyproject.toml

@@ -148,12 +148,6 @@ oracle = [
 odbc = [
     "pyodbc==5.1.0",
 ]
-clickhouse = [
-  "clickhouse-connect==0.8.14",
-  "clickhouse-driver==0.2.9",
-  "clickhouse-sqlalchemy==0.2.7",
-  "zstd==1.5.6.1",
-]
 
 [project.urls]
 Homepage = "https://github.com/bruin-data/ingestr"

{ingestr-0.13.16 → ingestr-0.13.17}/requirements.txt

@@ -43,3 +43,8 @@ dataclasses-json==0.6.7
 gcsfs==2024.10.0
 simple-salesforce==1.12.6
 databricks-sqlalchemy==1.0.2
+clickhouse-connect==0.8.14
+clickhouse-driver==0.2.9
+clickhouse-sqlalchemy==0.2.7
+zstd==1.5.6.5
+

ingestr-0.13.16/ingestr/src/buildinfo.py

@@ -1 +0,0 @@
-version = "v0.13.16"