ingestr 0.7.7__py3-none-any.whl → 0.7.8__py3-none-any.whl

ingestr/src/klaviyo/_init_.py

@@ -0,0 +1,173 @@
+from typing import Iterable
+
+import dlt
+import pendulum
+import requests
+from dlt.common.time import ensure_pendulum_datetime
+from dlt.common.typing import TAnyDateTime, TDataItem
+from dlt.sources import DltResource
+from dlt.sources.helpers.requests import Client
+
+from ingestr.src.klaviyo.client import KlaviyoClient
+from ingestr.src.klaviyo.helpers import split_date_range
+
+
+def retry_on_limit(response: requests.Response, exception: BaseException) -> bool:
+    return response.status_code == 429
+
+
+def create_client() -> requests.Session:
+    return Client(
+        request_timeout=10.0,
+        raise_for_status=False,
+        retry_condition=retry_on_limit,
+        request_max_attempts=12,
+        request_backoff_factor=2,
+    ).session
+
+
+@dlt.source(max_table_nesting=0)
+def klaviyo_source(api_key: str, start_date: TAnyDateTime) -> Iterable[DltResource]:
+    start_date_obj = ensure_pendulum_datetime(start_date)
+    client = KlaviyoClient(api_key)
+
+    @dlt.resource(write_disposition="append", primary_key="id", parallelized=True)
+    def events(
+        datetime=dlt.sources.incremental("datetime", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(datetime.start_value), pendulum.now()
+        )
+
+        for start, end in intervals:
+            yield lambda s=start, e=end: client.fetch_events(create_client(), s, e)
+
+    @dlt.resource(write_disposition="merge", primary_key="id", parallelized=True)
+    def profiles(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(updated.start_value), pendulum.now()
+        )
+
+        for start, end in intervals:
+            yield lambda s=start, e=end: client.fetch_profiles(create_client(), s, e)
+
+    @dlt.resource(write_disposition="merge", primary_key="id", parallelized=True)
+    def campaigns(
+        updated_at=dlt.sources.incremental("updated_at", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(updated_at.start_value), pendulum.now()
+        )
+
+        for campaign_type in ["email", "sms"]:
+            for start, end in intervals:
+                yield lambda s=start, e=end, ct=campaign_type: client.fetch_campaigns(
+                    create_client(), s, e, ct
+                )
+
+    @dlt.resource(write_disposition="merge", primary_key="id")
+    def metrics(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        yield from client.fetch_metrics(create_client(), updated.start_value)
+
+    @dlt.resource(write_disposition="replace", primary_key="id")
+    def tags() -> Iterable[TAnyDateTime]:
+        yield from client.fetch_tag(create_client())
+
+    @dlt.resource(write_disposition="replace", primary_key="id")
+    def coupons() -> Iterable[TAnyDateTime]:
+        yield from client.fetch_coupons(create_client())
+
+    @dlt.resource(write_disposition="merge", primary_key="id", name="catalog-variants")
+    def catalog_variants(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        yield from client.fetch_catalog_variant(create_client(), updated.start_value)
+
+    @dlt.resource(
+        write_disposition="merge", primary_key="id", name="catalog-categories"
+    )
+    def catalog_categories(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        yield from client.fetch_catalog_categories(create_client(), updated.start_value)
+
+    @dlt.resource(write_disposition="merge", primary_key="id", name="catalog-items")
+    def catalog_items(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        yield from client.fetch_catalog_item(create_client(), updated.start_value)
+
+    @dlt.resource(write_disposition="append", primary_key="id", parallelized=True)
+    def forms(
+        updated_at=dlt.sources.incremental("updated_at", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(updated_at.start_value), pendulum.now()
+        )
+
+        for start, end in intervals:
+            yield lambda s=start, e=end: client.fetch_forms(create_client(), s, e)
+
+    @dlt.resource(write_disposition="merge", primary_key="id")
+    def lists(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        yield from client.fetch_lists(create_client(), updated.start_value)
+
+    @dlt.resource(write_disposition="append", primary_key="id", parallelized=True)
+    def images(
+        updated_at=dlt.sources.incremental("updated_at", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(updated_at.start_value), pendulum.now()
+        )
+        for start, end in intervals:
+            yield lambda s=start, e=end: client.fetch_images(create_client(), s, e)
+
+    @dlt.resource(write_disposition="merge", primary_key="id")
+    def segments(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        yield from client.fetch_segments(create_client(), updated.start_value)
+
+    @dlt.resource(write_disposition="append", primary_key="id", parallelized=True)
+    def flows(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(updated.start_value), pendulum.now()
+        )
+        for start, end in intervals:
+            yield lambda s=start, e=end: client.fetch_flows(create_client(), s, e)
+
+    @dlt.resource(write_disposition="append", primary_key="id", parallelized=True)
+    def templates(
+        updated=dlt.sources.incremental("updated", start_date_obj.isoformat()),
+    ) -> Iterable[TDataItem]:
+        intervals = split_date_range(
+            pendulum.parse(updated.start_value), pendulum.now()
+        )
+        for start, end in intervals:
+            yield lambda s=start, e=end: client.fetch_templates(create_client(), s, e)
+
+    return (
+        events,
+        profiles,
+        campaigns,
+        metrics,
+        tags,
+        coupons,
+        catalog_variants,
+        catalog_categories,
+        catalog_items,
+        forms,
+        lists,
+        images,
+        segments,
+        flows,
+        templates,
+    )

ingestr/src/klaviyo/client.py

@@ -0,0 +1,212 @@
+from urllib.parse import urlencode
+
+import pendulum
+import requests
+
+BASE_URL = "https://a.klaviyo.com/api"
+
+
+class KlaviyoClient:
+    def __init__(self, api_key: str):
+        self.api_key = api_key
+
+    def __get_headers(self):
+        return {
+            "Authorization": f"Klaviyo-API-Key {self.api_key}",
+            "accept": "application/json",
+            "revision": "2024-07-15",
+        }
+
+    def _flatten_attributes(self, items: list):
+        for event in items:
+            if "attributes" not in event:
+                continue
+
+            for attribute_key in event["attributes"]:
+                event[attribute_key] = event["attributes"][attribute_key]
+
+            del event["attributes"]
+        return items
+
+    def _fetch_pages(
+        self, session: requests.Session, url: str, flat: bool = True
+    ) -> list:
+        all_items = []
+        while True:
+            response = session.get(url=url, headers=self.__get_headers())
+            result = response.json()
+            items = result.get("data", [])
+
+            if flat:
+                items = self._flatten_attributes(items)
+
+            all_items.extend(items)
+            nextURL = result.get("links", {}).get("next")
+            if nextURL is None:
+                break
+
+            url = nextURL
+
+        return all_items
+
+    def fetch_events(
+        self,
+        session: requests.Session,
+        start_date: str,
+        end_date: str,
+    ):
+        print(f"Fetching events for {start_date} to {end_date}")
+        url = f"{BASE_URL}/events/?sort=-datetime&filter=and(greater-or-equal(datetime,{start_date}),less-than(datetime,{end_date}))"
+        return self._fetch_pages(session, url)
+
+    def fetch_metrics(
+        self,
+        session: requests.Session,
+        last_updated: str,
+    ):
+        print(f"Fetching metrics since {last_updated}")
+        url = f"{BASE_URL}/metrics"
+        items = self._fetch_pages(session, url)
+
+        last_updated_obj = pendulum.parse(last_updated)
+        for item in items:
+            updated_at = pendulum.parse(item["updated"])
+            if updated_at > last_updated_obj:
+                yield item
+
+    def fetch_profiles(
+        self,
+        session: requests.Session,
+        start_date: str,
+        end_date: str,
+    ):
+        pendulum_start_date = pendulum.parse(start_date)
+        pendulum_start_date = pendulum_start_date.subtract(seconds=1)
+        url = f"{BASE_URL}/profiles/?sort=updated&filter=and(greater-than(updated,{pendulum_start_date.isoformat()}),less-than(updated,{end_date}))"
+        return self._fetch_pages(session, url)
+
+    def fetch_campaigns(
+        self,
+        session: requests.Session,
+        start_date: str,
+        end_date: str,
+        campaign_type: str,
+    ):
+        print(f"Fetching {campaign_type} campaigns for {start_date} to {end_date}")
+
+        base_url = f"{BASE_URL}/campaigns/"
+        params = {
+            "sort": "updated_at",
+            "filter": f"and(equals(messages.channel,'{campaign_type}'),greater-or-equal(updated_at,{start_date}),less-than(updated_at,{end_date}))",
+        }
+        url = f"{base_url}?{urlencode(params)}"
+        pages = self._fetch_pages(session, url)
+        for page in pages:
+            page["campaign_type"] = campaign_type
+
+        return pages
+
+    def fetch_tag(self, session: requests.Session):
+        url = f"{BASE_URL}/tags"
+        return self._fetch_pages(session, url, False)
+
+    def fetch_catalog_variant(
+        self,
+        session: requests.Session,
+        last_updated: str,
+    ):
+        url = f"{BASE_URL}/catalog-variants"
+        items = self._fetch_pages(session, url)
+        last_updated_obj = pendulum.parse(last_updated)
+
+        for item in items:
+            updated_at = pendulum.parse(item["updated"])
+            if updated_at > last_updated_obj:
+                yield item
+
+    def fetch_coupons(self, session: requests.Session):
+        url = f"{BASE_URL}/coupons"
+        return self._fetch_pages(session, url, False)
+
+    def fetch_catalog_categories(
+        self,
+        session: requests.Session,
+        last_updated: str,
+    ):
+        url = f"{BASE_URL}/catalog-categories"
+        items = self._fetch_pages(session, url)
+        last_updated_obj = pendulum.parse(last_updated)
+
+        for item in items:
+            updated_at = pendulum.parse(item["updated"])
+            if updated_at > last_updated_obj:
+                yield item
+
+    def fetch_catalog_item(
+        self,
+        session: requests.Session,
+        last_updated: str,
+    ):
+        url = f"{BASE_URL}/catalog-items"
+        items = self._fetch_pages(session, url)
+        last_updated_obj = pendulum.parse(last_updated)
+
+        for item in items:
+            updated_at = pendulum.parse(item["updated"])
+            if updated_at > last_updated_obj:
+                yield item
+
+    def fetch_forms(
+        self,
+        session: requests.Session,
+        start_date: str,
+        end_date: str,
+    ):
+        print(f"Fetching forms for {start_date} to {end_date}")
+        url = f"{BASE_URL}/forms/?sort=-updated_at&filter=and(greater-or-equal(updated_at,{start_date}),less-than(updated_at,{end_date}))"
+        return self._fetch_pages(session, url)
+
+    def fetch_lists(
+        self,
+        session: requests.Session,
+        updated_date: str,
+    ):
+        # https://a.klaviyo.com/api/lists/?sort=-updated&filter=greater-than(updated,2024-02-01 00:00:00+00:00)
+        url = f"{BASE_URL}/lists/?sort=-updated&filter=greater-than(updated,{updated_date})"
+        return self._fetch_pages(session, url)
+
+    def fetch_images(self, session: requests.Session, start_date: str, end_date: str):
+        # https://a.klaviyo.com/api/images/?sort=-updated_at&filter=greater-or-equal(updated_at,2024-06-01 00:00:00+00:00),less-than(updated_at,2024-09-01 00:00:00+00:00)
+        url = f"{BASE_URL}/images/?sort=-updated_at&filter=and(greater-or-equal(updated_at,{start_date}),less-than(updated_at,{end_date}))"
+        return self._fetch_pages(session, url)
+
+    def fetch_segments(
+        self,
+        session: requests.Session,
+        updated_date: str,
+    ):
+        # https://a.klaviyo.com/api/segments/?sort=-updated&filter=greater-than(updated,2024-04-01 00:00:00+00:00)
+        url = f"{BASE_URL}/segments/?sort=-updated&filter=greater-than(updated,{updated_date})"
+        print("url", url)
+        return self._fetch_pages(session, url)
+
+    def fetch_flows(
+        self,
+        session: requests.Session,
+        start_date: str,
+        end_date: str,
+    ):
+        print(f"Fetching events for {start_date} to {end_date}")
+        # https://a.klaviyo.com/api/flows/?sort=-updated&filter=and(greater-or-equal(updated,2024-06-01 00:00:00+00:00),less-than(updated,2024-09-01 00:00:00+00:00))
+        url = f"{BASE_URL}/flows/?sort=-updated&filter=and(greater-or-equal(updated,{start_date}),less-than(updated,{end_date}))"
+        return self._fetch_pages(session, url)
+
+    def fetch_templates(
+        self,
+        session: requests.Session,
+        start_date: str,
+        end_date: str,
+    ):
+        # https://a.klaviyo.com/api/templates/?sort=-updated&filter=and(greater-or-equal(updated,2024-06-01 00:00:00+00:00),less-than(updated,2024-09-01 00:00:00+00:00))
+        url = f"{BASE_URL}/templates/?sort=-updated&filter=and(greater-or-equal(updated,{start_date}),less-than(updated,{end_date}))"
+        return self._fetch_pages(session, url)

ingestr/src/klaviyo/helpers.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pendulum
+
+
+def split_date_range(
+    start_date: pendulum.DateTime, end_date: pendulum.DateTime
+) -> List[tuple]:
+    interval = "days"
+    if (end_date - start_date).days <= 1:
+        interval = "hours"
+
+    intervals = []
+    current = start_date
+    while current < end_date:
+        next_date = min(current.add(**{interval: 1}), end_date)
+        intervals.append((current.isoformat(), next_date.isoformat()))
+        current = next_date
+    return intervals

ingestr/src/sources.py

@@ -9,9 +9,13 @@ import dlt
 
 from ingestr.src.airtable import airtable_source
 from ingestr.src.chess import source
+from ingestr.src.facebook_ads import facebook_ads_source, facebook_insights_source
 from ingestr.src.google_sheets import google_spreadsheet
 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.klaviyo._init_ import klaviyo_source
 from ingestr.src.mongodb import mongodb_collection
 from ingestr.src.notion import notion_databases
 from ingestr.src.shopify import shopify_source
@@ -405,6 +409,48 @@ class StripeAnalyticsSource:
         ).with_resources(endpoint)
 
 
+class FacebookAdsSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        # facebook_ads://?access_token=abcd&account_id=1234
+        if kwargs.get("incremental_key"):
+            raise ValueError(
+                "Facebook Ads takes care of incrementality on its own, you should not provide incremental_key"
+            )
+
+        access_token = None
+        account_id = None
+        source_field = urlparse(uri)
+        source_params = parse_qs(source_field.query)
+        access_token = source_params.get("access_token")
+        account_id = source_params.get("account_id")
+
+        if not access_token or not account_id:
+            raise ValueError(
+                "access_token and accound_id are required to connect to Facebook Ads."
+            )
+
+        endpoint = None
+        if table in ["campaigns", "ad_sets", "ad_creatives", "ads", "leads"]:
+            endpoint = table
+        elif table in "facebook_insights":
+            return facebook_insights_source(
+                access_token=access_token[0],
+                account_id=account_id[0],
+            ).with_resources("facebook_insights")
+        else:
+            raise ValueError(
+                "fResource '{table}' is not supported for Facebook Ads source yet, if you are interested in it please create a GitHub issue at https://github.com/bruin-data/ingestr"
+            )
+
+        return facebook_ads_source(
+            access_token=access_token[0],
+            account_id=account_id[0],
+        ).with_resources(endpoint)
+
+
 class SlackSource:
     def handles_incrementality(self) -> bool:
         return True
@@ -511,3 +557,98 @@ class AirtableSource:
         return airtable_source(
             base_id=base_id[0], table_names=tables, access_token=access_token[0]
         )
+
+
+class KlaviyoSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        if kwargs.get("incremental_key"):
+            raise ValueError(
+                "klaviyo_source takes care of incrementality on its own, you should not provide incremental_key"
+            )
+
+        source_fields = urlparse(uri)
+        source_params = parse_qs(source_fields.query)
+        api_key = source_params.get("api_key")
+
+        if not api_key:
+            raise ValueError("api_key in the URI is required to connect to klaviyo")
+
+        resource = None
+        if table in [
+            "events",
+            "profiles",
+            "campaigns",
+            "metrics",
+            "tags",
+            "coupons",
+            "catalog-variants",
+            "catalog-categories",
+            "catalog-items",
+            "forms",
+            "lists",
+            "images",
+            "segments",
+            "flows",
+            "templates",
+        ]:
+            resource = table
+        else:
+            raise ValueError(
+                f"Resource '{table}' is not supported for Klaviyo source yet, if you are interested in it please create a GitHub issue at https://github.com/bruin-data/ingestr"
+            )
+
+        start_date = kwargs.get("interval_start") or "2000-01-01"
+        return klaviyo_source(
+            api_key=api_key[0],
+            start_date=start_date,
+        ).with_resources(resource)
+
+
+class KafkaSource:
+    def handles_incrementality(self) -> bool:
+        return False
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        # kafka://?bootstrap_servers=localhost:9092&group_id=test_group&security_protocol=SASL_SSL&sasl_mechanisms=PLAIN&sasl_username=example_username&sasl_password=example_secret
+        source_fields = urlparse(uri)
+        source_params = parse_qs(source_fields.query)
+
+        bootstrap_servers = source_params.get("bootstrap_servers")
+        group_id = source_params.get("group_id")
+        security_protocol = source_params.get("security_protocol", [])
+        sasl_mechanisms = source_params.get("sasl_mechanisms", [])
+        sasl_username = source_params.get("sasl_username", [])
+        sasl_password = source_params.get("sasl_password", [])
+        batch_size = source_params.get("batch_size", [3000])
+        batch_timeout = source_params.get("batch_timeout", [3])
+
+        if not bootstrap_servers:
+            raise ValueError(
+                "bootstrap_servers in the URI is required to connect to kafka"
+            )
+
+        if not group_id:
+            raise ValueError("group_id in the URI is required to connect to kafka")
+
+        start_date = kwargs.get("interval_start")
+        return kafka_consumer(
+            topics=[table],
+            credentials=KafkaCredentials(
+                bootstrap_servers=bootstrap_servers[0],
+                group_id=group_id[0],
+                security_protocol=security_protocol[0]
+                if len(security_protocol) > 0
+                else None,  # type: ignore
+                sasl_mechanisms=sasl_mechanisms[0]
+                if len(sasl_mechanisms) > 0
+                else None,  # type: ignore
+                sasl_username=sasl_username[0] if len(sasl_username) > 0 else None,  # type: ignore
+                sasl_password=sasl_password[0] if len(sasl_password) > 0 else None,  # type: ignore
+            ),
+            start_from=start_date,
+            batch_size=int(batch_size[0]),
+            batch_timeout=int(batch_timeout[0]),
+        )

ingestr/src/version.py

@@ -1 +1 @@
-__version__ = "0.7.7"
+__version__ = "0.7.8"

{ingestr-0.7.7.dist-info → ingestr-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ingestr
-Version: 0.7.7
+Version: 0.7.8
 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
@@ -14,11 +14,13 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Database
 Requires-Python: >=3.9
+Requires-Dist: confluent-kafka>=2.3.0
 Requires-Dist: cx-oracle==8.3.0
 Requires-Dist: databricks-sql-connector==2.9.3
 Requires-Dist: dlt==0.5.1
 Requires-Dist: duckdb-engine==0.11.5
 Requires-Dist: duckdb==0.10.2
+Requires-Dist: facebook-business==20.0.0
 Requires-Dist: google-api-python-client==2.130.0
 Requires-Dist: google-cloud-bigquery-storage==2.24.0
 Requires-Dist: mysql-connector-python==9.0.0
@@ -185,6 +187,11 @@ Join our Slack community [here](https://join.slack.com/t/bruindatacommunity/shar
         <td>Chess.com</td>
         <td>✅</td>
         <td>-</td>
+    </tr>
+     <tr>
+        <td>Facebook Ads</td>
+        <td>✅</td>
+        <td>-</td>
     </tr>
     <tr>
         <td>Gorgias</td>
@@ -200,6 +207,11 @@ Join our Slack community [here](https://join.slack.com/t/bruindatacommunity/shar
         <td>HubSpot</td>
         <td>✅</td>
         <td>-</td>
+    </tr>
+     <tr>
+        <td>Klaviyo</td>
+        <td>✅</td>
+        <td>-</td>
     </tr>
     <tr>
         <td>Notion</td>

{ingestr-0.7.7.dist-info → ingestr-0.7.8.dist-info}/RECORD

@@ -1,13 +1,18 @@
-ingestr/main.py,sha256=dUh9D-i5EJJKJQOu29okpPebJ6y9w0unTCNm6f7k2Bk,17184
+ingestr/main.py,sha256=Hlcb8mUAWoGZr4ZKtQnoEhjLkjroiwx2-J86C6fN37E,17596
+ingestr/src/.gitignore,sha256=8cX1AZTSI0TcdZFGTmS_oyBjpfCzhOEt0DdAo2dFIY8,203
 ingestr/src/destinations.py,sha256=2SfPMjtTelPmzQmc3zNs8xGcKIPuGn_hoZFIBUuhjXI,6338
-ingestr/src/factory.py,sha256=OOHlQ4TZNG-1FVK-w7nnKfYVmQE7GLJlqw-gPxCUfg0,4136
-ingestr/src/sources.py,sha256=Wi74uPHjPzdoIXBY5Ha4ZW1Mdh2L3xAiMWnZekPu4ws,17307
+ingestr/src/factory.py,sha256=CTVaFeMVgZO1fC9AKOqx-Wu89l5_YL6GlmvDF-FkAew,4442
+ingestr/src/sources.py,sha256=BlMsajIMcu_oqmU38uqlasXz2vtN_J8yXa24NHFcwJA,22696
 ingestr/src/table_definition.py,sha256=REbAbqdlmUMUuRh8nEQRreWjPVOQ5ZcfqGkScKdCrmk,390
-ingestr/src/version.py,sha256=eOm8myGPtPLNpkuxL0xhVmstPQbwXv3Ok7FbH0re-TA,22
+ingestr/src/version.py,sha256=uC8wB9mRblQ0jUBAOUyCQLUQJ39MC2xybVLB_8ZsevU,22
 ingestr/src/airtable/__init__.py,sha256=GHWYrjI2qhs_JihdNJysB0Ni3bzqT_MLXn_S9_Q5zRA,2775
 ingestr/src/chess/__init__.py,sha256=PaxT2DObudOGlhyoENE5LjR6rTdsxiqKKpAZeyzVLCA,6791
 ingestr/src/chess/helpers.py,sha256=v1HTImOMjAF7AzZUPDIuHu00e7ut0o5y1kWcVYo4QZw,549
 ingestr/src/chess/settings.py,sha256=p0RlCGgtXUacPDEvZmwzSWmzX0Apj1riwfz-nrMK89k,158
+ingestr/src/facebook_ads/__init__.py,sha256=ZZyogV48gmhDcC3CYQEsC4qT3Q6JI9IOnMff2NS1M-A,9207
+ingestr/src/facebook_ads/exceptions.py,sha256=4Nlbc0Mv3i5g-9AoyT-n1PIa8IDi3VCTfEAzholx4Wc,115
+ingestr/src/facebook_ads/helpers.py,sha256=ZLbNHiKer5lPb4g3_435XeBJr57Wv0o1KTyBA1mQ100,9068
+ingestr/src/facebook_ads/settings.py,sha256=1IxZeP_4rN3IBvAncNHOoqpzAirx0Hz-MUK_tl6UTFk,4881
 ingestr/src/google_sheets/README.md,sha256=wFQhvmGpRA38Ba2N_WIax6duyD4c7c_pwvvprRfQDnw,5470
 ingestr/src/google_sheets/__init__.py,sha256=5qlX-6ilx5MW7klC7B_0jGSxloQSLkSESTh4nlY3Aos,6643
 ingestr/src/google_sheets/helpers/__init__.py,sha256=5hXZrZK8cMO3UOuL-s4OKOpdACdihQD0hYYlSEu-iQ8,35
@@ -18,6 +23,11 @@ ingestr/src/gorgias/helpers.py,sha256=DamuijnvhGY9hysQO4txrVMf4izkGbh5qfBKImdOIN
 ingestr/src/hubspot/__init__.py,sha256=eSD_lEIEd16YijAtUATFG8FGO8YGPm-MtAk94KKsx6o,9740
 ingestr/src/hubspot/helpers.py,sha256=PTn-UHJv1ENIvA5azUTaHCmFXgmHLJC1tUatQ1N-KFE,6727
 ingestr/src/hubspot/settings.py,sha256=9P1OKiRL88kl_m8n1HhuG-Qpq9VGbqPLn5Q0QYneToU,2193
+ingestr/src/kafka/__init__.py,sha256=wMCXdiraeKd1Kssi9WcVCGZaNGm2tJEtnNyuB4aR5_k,3541
+ingestr/src/kafka/helpers.py,sha256=V9WcVn3PKnEpggArHda4vnAcaV8VDuh__dSmRviJb5Y,7502
+ingestr/src/klaviyo/_init_.py,sha256=nq2T1p3Xc7yiwGabsZBp2Jy2fa8_n5oxqxBnUGhKOgg,6592
+ingestr/src/klaviyo/client.py,sha256=tPj79ia7AW0ZOJhzlKNPCliGbdojRNwUFp8HvB2ym5s,7434
+ingestr/src/klaviyo/helpers.py,sha256=_i-SHffhv25feLDcjy6Blj1UxYLISCwVCMgGtrlnYHk,496
 ingestr/src/mongodb/__init__.py,sha256=E7SDeCyYNkYZZ_RFhjCRDZUGpKtaxpPG5sFSmKJV62U,4336
 ingestr/src/mongodb/helpers.py,sha256=80vtAeNyUn1iMN0CeLrTlKqYN6I6fHF81Kd2UuE8Kns,5653
 ingestr/src/notion/__init__.py,sha256=36wUui8finbc85ObkRMq8boMraXMUehdABN_AMe_hzA,1834
@@ -50,8 +60,8 @@ ingestr/testdata/delete_insert_part2.csv,sha256=B_KUzpzbNdDY_n7wWop1mT2cz36TmayS
 ingestr/testdata/merge_expected.csv,sha256=DReHqWGnQMsf2PBv_Q2pfjsgvikYFnf1zYcQZ7ZqYN0,276
 ingestr/testdata/merge_part1.csv,sha256=Pw8Z9IDKcNU0qQHx1z6BUf4rF_-SxKGFOvymCt4OY9I,185
 ingestr/testdata/merge_part2.csv,sha256=T_GiWxA81SN63_tMOIuemcvboEFeAmbKc7xRXvL9esw,287
-ingestr-0.7.7.dist-info/METADATA,sha256=zzWW5as6aboO_I7_iD02tMTDOS_yiAWHqLddbjxOLEY,6307
-ingestr-0.7.7.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-ingestr-0.7.7.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
-ingestr-0.7.7.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
-ingestr-0.7.7.dist-info/RECORD,,
+ingestr-0.7.8.dist-info/METADATA,sha256=JGJ_76vC0icT_tJSYDkbtRXuc_63sgHXJYYIksTSyOE,6561
+ingestr-0.7.8.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+ingestr-0.7.8.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
+ingestr-0.7.8.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
+ingestr-0.7.8.dist-info/RECORD,,