ingestr 0.13.13__py3-none-any.whl → 0.14.104__py3-none-any.whl

ingestr/src/appsflyer/__init__.py

@@ -0,0 +1,325 @@
+from typing import Iterable
+
+import dlt
+import pendulum
+from dlt.common.typing import TDataItem
+from dlt.sources import DltResource
+
+from ingestr.src.appsflyer.client import AppsflyerClient
+
+DIMENSION_RESPONSE_MAPPING = {
+    "c": "campaign",
+    "af_adset_id": "adset_id",
+    "af_adset": "adset",
+    "af_ad_id": "ad_id",
+}
+HINTS = {
+    "app_id": {
+        "data_type": "text",
+        "nullable": False,
+    },
+    "campaign": {
+        "data_type": "text",
+        "nullable": False,
+    },
+    "geo": {
+        "data_type": "text",
+        "nullable": False,
+    },
+    "cost": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": False,
+    },
+    "clicks": {
+        "data_type": "bigint",
+        "nullable": False,
+    },
+    "impressions": {
+        "data_type": "bigint",
+        "nullable": False,
+    },
+    "average_ecpi": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": False,
+    },
+    "installs": {
+        "data_type": "bigint",
+        "nullable": False,
+    },
+    "retention_day_7": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": False,
+    },
+    "retention_day_14": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": False,
+    },
+    "cohort_day_1_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_1_total_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_3_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_3_total_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_7_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_7_total_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_14_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_14_total_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_21_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "cohort_day_21_total_revenue_per_user": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "install_time": {
+        "data_type": "date",
+        "nullable": False,
+    },
+    "loyal_users": {
+        "data_type": "bigint",
+        "nullable": False,
+    },
+    "revenue": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "roi": {
+        "data_type": "decimal",
+        "precision": 30,
+        "scale": 5,
+        "nullable": True,
+    },
+    "uninstalls": {
+        "data_type": "bigint",
+        "nullable": True,
+    },
+}
+
+CAMPAIGNS_DIMENSIONS = ["c", "geo", "app_id", "install_time"]
+CAMPAIGNS_METRICS = [
+    "average_ecpi",
+    "clicks",
+    "cohort_day_1_revenue_per_user",
+    "cohort_day_1_total_revenue_per_user",
+    "cohort_day_14_revenue_per_user",
+    "cohort_day_14_total_revenue_per_user",
+    "cohort_day_21_revenue_per_user",
+    "cohort_day_21_total_revenue_per_user",
+    "cohort_day_3_revenue_per_user",
+    "cohort_day_3_total_revenue_per_user",
+    "cohort_day_7_revenue_per_user",
+    "cohort_day_7_total_revenue_per_user",
+    "cost",
+    "impressions",
+    "installs",
+    "loyal_users",
+    "retention_day_7",
+    "revenue",
+    "roi",
+    "uninstalls",
+]
+
+CREATIVES_DIMENSIONS = [
+    "c",
+    "geo",
+    "app_id",
+    "install_time",
+    "af_adset_id",
+    "af_adset",
+    "af_ad_id",
+]
+CREATIVES_METRICS = [
+    "impressions",
+    "clicks",
+    "installs",
+    "cost",
+    "revenue",
+    "average_ecpi",
+    "loyal_users",
+    "uninstalls",
+    "roi",
+]
+
+
+@dlt.source(max_table_nesting=0)
+def appsflyer_source(
+    api_key: str,
+    start_date: str,
+    end_date: str,
+    dimensions: list[str],
+    metrics: list[str],
+) -> Iterable[DltResource]:
+    client = AppsflyerClient(api_key)
+
+    @dlt.resource(
+        write_disposition="merge",
+        merge_key="install_time",
+        columns=make_hints(CAMPAIGNS_DIMENSIONS, CAMPAIGNS_METRICS),
+    )
+    def campaigns(
+        datetime=dlt.sources.incremental(
+            "install_time",
+            initial_value=(
+                start_date
+                if start_date
+                else pendulum.today().subtract(days=30).format("YYYY-MM-DD")
+            ),
+            end_value=end_date,
+            range_end="closed",
+            range_start="closed",
+        ),
+    ) -> Iterable[TDataItem]:
+        end = (
+            datetime.end_value
+            if datetime.end_value
+            else pendulum.now().format("YYYY-MM-DD")
+        )
+
+        yield from client._fetch_data(
+            from_date=datetime.last_value,
+            to_date=end,
+            dimensions=CAMPAIGNS_DIMENSIONS,
+            metrics=CAMPAIGNS_METRICS,
+        )
+
+    @dlt.resource(
+        write_disposition="merge",
+        merge_key="install_time",
+        columns=make_hints(CREATIVES_DIMENSIONS, CREATIVES_METRICS),
+    )
+    def creatives(
+        datetime=dlt.sources.incremental(
+            "install_time",
+            initial_value=(
+                start_date
+                if start_date
+                else pendulum.today().subtract(days=30).format("YYYY-MM-DD")
+            ),
+            end_value=end_date,
+            range_end="closed",
+            range_start="closed",
+        ),
+    ) -> Iterable[TDataItem]:
+        end = (
+            datetime.end_value
+            if datetime.end_value
+            else pendulum.now().format("YYYY-MM-DD")
+        )
+        yield from client._fetch_data(
+            datetime.last_value,
+            end,
+            dimensions=CREATIVES_DIMENSIONS,
+            metrics=CREATIVES_METRICS,
+        )
+
+    primary_keys = []
+    if "install_time" not in dimensions:
+        dimensions.append("install_time")
+        primary_keys.append("install_time")
+
+    for dimension in dimensions:
+        if dimension in DIMENSION_RESPONSE_MAPPING:
+            primary_keys.append(DIMENSION_RESPONSE_MAPPING[dimension])
+        else:
+            primary_keys.append(dimension)
+
+    @dlt.resource(
+        write_disposition="merge",
+        primary_key=primary_keys,
+        columns=make_hints(dimensions, metrics),
+    )
+    def custom(
+        datetime=dlt.sources.incremental(
+            "install_time",
+            initial_value=(
+                start_date
+                if start_date
+                else pendulum.today().subtract(days=30).format("YYYY-MM-DD")
+            ),
+            end_value=end_date,
+        ),
+    ):
+        end = (
+            datetime.end_value
+            if datetime.end_value
+            else pendulum.now().format("YYYY-MM-DD")
+        )
+        res = client._fetch_data(
+            from_date=datetime.last_value,
+            to_date=end,
+            dimensions=dimensions,
+            metrics=metrics,
+        )
+        yield from res
+
+    return campaigns, creatives, custom
+
+
+def make_hints(dimensions: list[str], metrics: list[str]):
+    campaign_hints = {}
+    for dimension in dimensions:
+        resp_key = dimension
+        if dimension in DIMENSION_RESPONSE_MAPPING:
+            resp_key = DIMENSION_RESPONSE_MAPPING[dimension]
+
+        if resp_key in HINTS:
+            campaign_hints[resp_key] = HINTS[resp_key]
+
+    for metric in metrics:
+        if metric in HINTS:
+            campaign_hints[metric] = HINTS[metric]
+
+    return campaign_hints

ingestr/src/appsflyer/client.py

@@ -4,19 +4,6 @@ import requests
 from dlt.sources.helpers.requests import Client
 from requests.exceptions import HTTPError
 
-DEFAULT_GROUPING = ["c", "geo", "app_id", "install_time"]
-DEFAULT_KPIS = [
-    "impressions",
-    "clicks",
-    "installs",
-    "cost",
-    "revenue",
-    "average_ecpi",
-    "loyal_users",
-    "uninstalls",
-    "roi",
-]
-
 
 class AppsflyerClient:
     def __init__(self, api_key: str):
@@ -33,15 +20,20 @@ class AppsflyerClient:
         self,
         from_date: str,
         to_date: str,
+        dimensions: list[str],
+        metrics: list[str],
         maximum_rows=1000000,
-        dimensions=DEFAULT_GROUPING,
-        metrics=DEFAULT_KPIS,
     ):
+        excluded_metrics = exclude_metrics_for_date_range(metrics, from_date, to_date)
+        included_metrics = [
+            metric for metric in metrics if metric not in excluded_metrics
+        ]
+
         params = {
             "from": from_date,
             "to": to_date,
             "groupings": ",".join(dimensions),
-            "kpis": ",".join(metrics),
+            "kpis": ",".join(included_metrics),
             "format": "json",
             "maximum_rows": maximum_rows,
         }
@@ -54,7 +46,6 @@ class AppsflyerClient:
             )
 
         request_client = Client(
-            request_timeout=10.0,
             raise_for_status=False,
             retry_condition=retry_on_limit,
             request_max_attempts=12,
@@ -68,39 +59,52 @@ class AppsflyerClient:
 
             if response.status_code == 200:
                 result = response.json()
-                yield result
+                yield standardize_keys(result, excluded_metrics)
             else:
                 raise HTTPError(
-                    f"Request failed with status code: {response.status_code}"
+                    f"Request failed with status code: {response.status_code}: {response.text}"
                 )
 
         except requests.RequestException as e:
             raise HTTPError(f"Request failed: {e}")
 
-    def fetch_campaigns(
-        self,
-        start_date: str,
-        end_date: str,
-    ):
-        metrics = DEFAULT_KPIS + [
-            "cohort_day_1_revenue_per_user",
-            "cohort_day_1_total_revenue_per_user",
-            "cohort_day_3_revenue_per_user",
-            "cohort_day_3_total_revenue_per_user",
-            "cohort_day_7_total_revenue_per_user",
-            "cohort_day_7_revenue_per_user",
-            "cohort_day_14_total_revenue_per_user",
-            "cohort_day_14_revenue_per_user",
-            "cohort_day_21_total_revenue_per_user",
-            "cohort_day_21_revenue_per_user",
-            "retention_day_7",
-        ]
-        return self._fetch_data(start_date, end_date, metrics=metrics)
 
-    def fetch_creatives(
-        self,
-        start_date: str,
-        end_date: str,
-    ):
-        dimensions = DEFAULT_GROUPING + ["af_adset_id", "af_adset", "af_ad_id"]
-        return self._fetch_data(start_date, end_date, dimensions=dimensions)
+def standardize_keys(data: list[dict], excluded_metrics: list[str]) -> list[dict]:
+    def fix_key(key: str) -> str:
+        return key.lower().replace("-", "").replace("  ", "_").replace(" ", "_")
+
+    standardized = []
+    for item in data:
+        standardized_item = {}
+        for key, value in item.items():
+            standardized_item[fix_key(key)] = value
+
+        for metric in excluded_metrics:
+            if metric not in standardized_item:
+                standardized_item[fix_key(metric)] = None
+
+        standardized.append(standardized_item)
+
+    return standardized
+
+
+def exclude_metrics_for_date_range(
+    metrics: list[str], from_date: str, to_date: str
+) -> list[str]:
+    """
+    Some of the cohort metrics are not available if there hasn't been enough time to have data for that cohort.
+    This means if you request data for yesterday with cohort day 7 metrics, you will get an error because 7 days hasn't passed yet.
+    One would expect the API to handle this gracefully, but it doesn't.
+
+    This function will exclude the metrics that are not available for the given date range.
+    """
+    import pendulum
+
+    excluded_metrics = []
+    days_between_today_and_end = (pendulum.now() - pendulum.parse(to_date)).days  # type: ignore
+    for metric in metrics:
+        if "cohort_day_" in metric:
+            day_count = int(metric.split("_")[2])
+            if days_between_today_and_end <= day_count:
+                excluded_metrics.append(metric)
+    return excluded_metrics

ingestr/src/appstore/__init__.py

@@ -38,6 +38,7 @@ def app_store(
             name=resource.name,
             primary_key=resource.primary_key,
             columns=resource.columns,
+            write_disposition="merge",
         )(client, app_ids, resource.report_name, start_date, end_date)
 
 

ingestr/src/arrow/__init__.py

@@ -1,6 +1,7 @@
 from typing import Any, Optional
 
 import dlt
+import pyarrow as pa  # type: ignore
 from dlt.common.schema.typing import TColumnNames, TTableSchemaColumns
 from dlt.extract.items import TTableHintTemplate
 
@@ -21,7 +22,6 @@ def memory_mapped_arrow(
     def arrow_mmap(
         incremental: Optional[dlt.sources.incremental[Any]] = incremental,
     ):
-        import pyarrow as pa  # type: ignore
         import pyarrow.ipc as ipc  # type: ignore
 
         with pa.memory_map(path, "rb") as mmap:
@@ -71,3 +71,11 @@ def memory_mapped_arrow(
         yield table
 
     return arrow_mmap
+
+
+BATCH_SIZE = 1000
+
+
+def as_list(table: pa.Table):
+    for batch in table.to_batches(BATCH_SIZE):
+        yield from batch.to_pylist()

ingestr/src/asana_source/__init__.py

@@ -182,7 +182,7 @@ def tasks(
 
 @dlt.transformer(
     data_from=tasks,
-    write_disposition="append",
+    write_disposition="replace",
 )
 @dlt.defer
 def stories(

ingestr/src/attio/__init__.py

@@ -0,0 +1,102 @@
+from typing import Iterable, Iterator
+
+import dlt
+from dlt.sources import DltResource
+
+from .helpers import AttioClient
+
+
+@dlt.source(max_table_nesting=0)
+def attio_source(
+    api_key: str,
+    params: list[str],
+) -> Iterable[DltResource]:
+    attio_client = AttioClient(api_key)
+
+    @dlt.resource(
+        name="objects",
+        write_disposition="replace",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    # https://docs.attio.com/rest-api/endpoint-reference/objects/list-objects - does not support pagination
+    def fetch_objects() -> Iterator[dict]:
+        if len(params) != 0:
+            raise ValueError("Objects table must be in the format `objects`")
+
+        path = "objects"
+        yield attio_client.fetch_all(path, "get")
+
+    # https://docs.attio.com/rest-api/endpoint-reference/records/list-records
+    @dlt.resource(
+        name="records",
+        write_disposition="replace",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_records() -> Iterator[dict]:
+        if len(params) != 1:
+            raise ValueError(
+                "Records table must be in the format `records:{object_api_slug}`"
+            )
+        object_id = params[0]
+        path = f"objects/{object_id}/records/query"
+
+        yield attio_client.fetch_paginated(path, "post")
+
+    # https://docs.attio.com/rest-api/endpoint-reference/lists/list-all-lists -- does not support pagination
+    @dlt.resource(
+        name="lists",
+        write_disposition="replace",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_lists() -> Iterator[dict]:
+        path = "lists"
+        yield attio_client.fetch_all(path, "get")
+
+    # https://docs.attio.com/rest-api/endpoint-reference/entries/list-entries
+    @dlt.resource(
+        name="list_entries",
+        write_disposition="replace",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_list_entries() -> Iterator[dict]:
+        if len(params) != 1:
+            raise ValueError(
+                "List entries table must be in the format `list_entries:{list_id}`"
+            )
+        path = f"lists/{params[0]}/entries/query"
+
+        yield attio_client.fetch_paginated(path, "post")
+
+    @dlt.resource(
+        name="all_list_entries",
+        write_disposition="replace",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_all_list_entries() -> Iterator[dict]:
+        if len(params) != 1:
+            raise ValueError(
+                "All list entries table must be in the format `all_list_entries:{object_api_slug}`"
+            )
+        path = "lists"
+        for lst in attio_client.fetch_all(path, "get"):
+            if params[0] in lst["parent_object"]:
+                path = f"lists/{lst['id']['list_id']}/entries/query"
+                yield from attio_client.fetch_paginated(path, "post")
+
+    return (
+        fetch_objects,
+        fetch_records,
+        fetch_lists,
+        fetch_list_entries,
+        fetch_all_list_entries,
+    )

ingestr/src/attio/helpers.py

@@ -0,0 +1,65 @@
+from ingestr.src.http_client import create_client
+
+
+class AttioClient:
+    def __init__(self, api_key: str):
+        self.base_url = "https://api.attio.com/v2"
+        self.headers = {
+            "Accept": "application/json",
+            "Authorization": f"Bearer {api_key}",
+        }
+        self.client = create_client()
+
+    def fetch_paginated(self, path: str, method: str, limit: int = 1000, params=None):
+        url = f"{self.base_url}/{path}"
+        if params is None:
+            params = {}
+        offset = 0
+        while True:
+            query_params = {"limit": limit, "offset": offset, **params}
+            if method == "get":
+                response = self.client.get(
+                    url, headers=self.headers, params=query_params
+                )
+            else:
+                json_body = {**params, "limit": limit, "offset": offset}
+                response = self.client.post(url, headers=self.headers, json=json_body)
+
+            if response.status_code != 200:
+                raise Exception(f"HTTP {response.status_code} error: {response.text}")
+
+            response_data = response.json()
+            if "data" not in response_data:
+                raise Exception(
+                    "Attio API returned a response without the expected data"
+                )
+
+            data = response_data["data"]
+            for item in data:
+                flat_item = flatten_item(item)
+                yield flat_item
+            if len(data) < limit:
+                break
+
+            offset += limit
+
+    def fetch_all(self, path: str, method: str = "get", params=None):
+        url = f"{self.base_url}/{path}"
+        params = params or {}
+
+        if method == "get":
+            response = self.client.get(url, headers=self.headers, params=params)
+        else:
+            response = self.client.post(url, headers=self.headers, json=params)
+
+        response.raise_for_status()
+        data = response.json().get("data", [])
+        for item in data:
+            yield flatten_item(item)
+
+
+def flatten_item(item: dict) -> dict:
+    if "id" in item:
+        for key, value in item["id"].items():
+            item[key] = value
+    return item