ingestr 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

ingestr/src/sources.py

@@ -3,17 +3,42 @@ import csv
 import json
 import os
 import re
-from datetime import date
-from typing import Any, Callable, Optional
+from datetime import date, datetime
+from typing import (
+    Any,
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    Literal,
+    Optional,
+    Union,
+)
 from urllib.parse import ParseResult, parse_qs, quote, urlparse
 
 import dlt
 import pendulum
-from dlt.common.configuration.specs import AwsCredentials
+import sqlalchemy
+from dlt.common.configuration.specs import (
+    AwsCredentials,
+)
+from dlt.common.libs.sql_alchemy import (
+    Engine,
+    MetaData,
+)
 from dlt.common.time import ensure_pendulum_datetime
-from dlt.common.typing import TSecretStrValue
+from dlt.common.typing import TDataItem, TSecretStrValue
+from dlt.extract import Incremental
 from dlt.sources.credentials import ConnectionStringCredentials
 from dlt.sources.sql_database import sql_table
+from dlt.sources.sql_database.helpers import TableLoader
+from dlt.sources.sql_database.schema_types import (
+    ReflectionLevel,
+    SelectAny,
+    Table,
+    TTypeAdapter,
+)
+from sqlalchemy import Column
 from sqlalchemy import types as sa
 from sqlalchemy.dialects import mysql
 
@@ -39,7 +64,7 @@ from ingestr.src.notion import notion_databases
 from ingestr.src.shopify import shopify_source
 from ingestr.src.slack import slack_source
 from ingestr.src.stripe_analytics import stripe_source
-from ingestr.src.table_definition import table_string_to_dataclass
+from ingestr.src.table_definition import TableDefinition, table_string_to_dataclass
 from ingestr.src.tiktok_ads import tiktok_source
 from ingestr.src.time import isotime
 from ingestr.src.zendesk import zendesk_chat, zendesk_support, zendesk_talk
@@ -48,6 +73,9 @@ from ingestr.src.zendesk.helpers.credentials import (
     ZendeskCredentialsToken,
 )
 
+TableBackend = Literal["sqlalchemy", "pyarrow", "pandas", "connectorx"]
+TQueryAdapter = Callable[[SelectAny, Table], SelectAny]
+
 
 class SqlSource:
     table_builder: Callable
@@ -59,7 +87,9 @@ class SqlSource:
         return False
 
     def dlt_source(self, uri: str, table: str, **kwargs):
-        table_fields = table_string_to_dataclass(table)
+        table_fields = TableDefinition(dataset="custom", table="custom")
+        if not table.startswith("query:"):
+            table_fields = table_string_to_dataclass(table)
 
         incremental = None
         if kwargs.get("incremental_key"):
@@ -87,6 +117,110 @@ class SqlSource:
                     query = query.order_by(kwargs.get("incremental_key"))
                 return query
 
+        defer_table_reflect = False
+        sql_backend = kwargs.get("sql_backend", "sqlalchemy")
+        if table.startswith("query:"):
+            if kwargs.get("sql_limit"):
+                raise ValueError(
+                    "sql_limit is not supported for custom queries, please apply the limit in the query instead"
+                )
+
+            sql_backend = "sqlalchemy"
+            defer_table_reflect = True
+            query_value = table.split(":", 1)[1]
+
+            # this is a very hacky version of the table_rows function. it is built this way to go around the dlt's table loader.
+            # I didn't want to write a full fledged sqlalchemy source for now, and wanted to benefit from the existing stuff to begin with.
+            # this is by no means a production ready solution, but it works for now.
+            # the core idea behind this implementation is to create a mock table instance with the columns that are absolutely necessary for the incremental load to work.
+            # the table loader will then use the query adapter callback to apply the actual query and load the rows.
+            def table_rows(
+                engine: Engine,
+                table: Union[Table, str],
+                metadata: MetaData,
+                chunk_size: int,
+                backend: TableBackend,
+                incremental: Optional[Incremental[Any]] = None,
+                table_adapter_callback: Callable[[Table], None] = None,  # type: ignore
+                reflection_level: ReflectionLevel = "minimal",
+                backend_kwargs: Dict[str, Any] = None,  # type: ignore
+                type_adapter_callback: Optional[TTypeAdapter] = None,
+                included_columns: Optional[List[str]] = None,
+                query_adapter_callback: Optional[TQueryAdapter] = None,
+                resolve_foreign_keys: bool = False,
+            ) -> Iterator[TDataItem]:
+                hints = {  # type: ignore
+                    "columns": [],
+                }
+                cols = []  # type: ignore
+
+                if incremental:
+                    switchDict = {
+                        int: sa.INTEGER,
+                        datetime: sa.TIMESTAMP,
+                        pendulum.Date: sa.DATE,
+                        pendulum.DateTime: sa.TIMESTAMP,
+                    }
+
+                    if incremental.last_value is not None:
+                        cols.append(
+                            Column(
+                                incremental.cursor_path,
+                                switchDict[type(incremental.last_value)],  # type: ignore
+                            )
+                        )
+                    else:
+                        cols.append(Column(incremental.cursor_path, sa.TIMESTAMP))  # type: ignore
+
+                table = Table(
+                    "query_result",
+                    metadata,
+                    *cols,
+                )
+
+                loader = TableLoader(
+                    engine,
+                    backend,
+                    table,
+                    hints["columns"],  # type: ignore
+                    incremental=incremental,
+                    chunk_size=chunk_size,
+                    query_adapter_callback=query_adapter_callback,
+                )
+                try:
+                    yield from loader.load_rows(backend_kwargs)
+                finally:
+                    if getattr(engine, "may_dispose_after_use", False):
+                        engine.dispose()
+
+            dlt.sources.sql_database.table_rows = table_rows
+
+            def query_adapter_callback(query, table, incremental=None, engine=None):
+                params = {}
+                if incremental:
+                    params["interval_start"] = (
+                        incremental.last_value
+                        if incremental.last_value is not None
+                        else datetime(year=1, month=1, day=1)
+                    )
+                    if incremental.end_value is not None:
+                        params["interval_end"] = incremental.end_value
+                else:
+                    if ":interval_start" in query_value:
+                        params["interval_start"] = (
+                            datetime.min
+                            if kwargs.get("interval_start") is None
+                            else kwargs.get("interval_start")
+                        )
+                    if ":interval_end" in query_value:
+                        params["interval_end"] = (
+                            datetime.max
+                            if kwargs.get("interval_end") is None
+                            else kwargs.get("interval_end")
+                        )
+
+                return sqlalchemy.text(query_value).bindparams(**params)
+
         def type_adapter_callback(sql_type):
             if isinstance(sql_type, mysql.SET):
                 return sa.JSON
@@ -97,7 +231,7 @@ class SqlSource:
             schema=table_fields.dataset,
             table=table_fields.table,
             incremental=incremental,
-            backend=kwargs.get("sql_backend", "sqlalchemy"),
+            backend=sql_backend,
             chunk_size=kwargs.get("page_size", None),
             reflection_level=reflection_level,
             query_adapter_callback=query_adapter_callback,
@@ -105,6 +239,7 @@ class SqlSource:
             table_adapter_callback=table_adapter_exclude_columns(
                 kwargs.get("sql_exclude_columns", [])
             ),
+            defer_table_reflect=defer_table_reflect,
         )
 
         return builder_res
@@ -1015,29 +1150,28 @@ class TikTokSource:
         if not access_token:
             raise ValueError("access_token is required to connect to TikTok")
 
-        time_zone = source_fields.get("time_zone", "UTC")
+        timezone = "UTC"
+        if source_fields.get("timezone") is not None:
+            timezone = source_fields.get("timezone")[0]  # type: ignore
+
+        advertiser_ids = source_fields.get("advertiser_ids")
+        if not advertiser_ids:
+            raise ValueError("advertiser_ids is required to connect to TikTok")
 
-        advertiser_id = source_fields.get("advertiser_id")
-        if not advertiser_id:
-            raise ValueError("advertiser_id is required to connect to TikTok")
+        advertiser_ids = advertiser_ids[0].replace(" ", "").split(",")
 
-        start_date = pendulum.now().subtract(days=90).in_tz(time_zone[0])
-        end_date = ensure_pendulum_datetime(pendulum.now()).in_tz(time_zone[0])
+        start_date = pendulum.now().subtract(days=30).in_tz(timezone)
+        end_date = ensure_pendulum_datetime(pendulum.now()).in_tz(timezone)
 
         interval_start = kwargs.get("interval_start")
         if interval_start is not None:
-            start_date = ensure_pendulum_datetime(interval_start).in_tz(time_zone[0])
+            start_date = ensure_pendulum_datetime(interval_start).in_tz(timezone)
 
         interval_end = kwargs.get("interval_end")
         if interval_end is not None:
-            end_date = ensure_pendulum_datetime(interval_end).in_tz(time_zone[0])
+            end_date = ensure_pendulum_datetime(interval_end).in_tz(timezone)
 
-        page_size = kwargs.get("page_size")
-        if page_size is not None and not isinstance(page_size, int):
-            page_size = int(page_size)
-
-        if page_size > 1000:
-            page_size = 1000
+        page_size = min(1000, kwargs.get("page_size", 1000))
 
         if table.startswith("custom:"):
             fields = table.split(":", 3)
@@ -1049,28 +1183,61 @@ class TikTokSource:
             dimensions = fields[1].replace(" ", "").split(",")
             if (
                 "campaign_id" not in dimensions
-                and "advertiser_id" not in dimensions
                 and "adgroup_id" not in dimensions
                 and "ad_id" not in dimensions
             ):
                 raise ValueError(
-                    "You must provide one ID dimension. Please use one ID dimension from the following options: [campaign_id, advertiser_id, adgroup_id, ad_id]"
+                    "TikTok API requires at least one ID dimension, please use one of the following dimensions: [campaign_id, adgroup_id, ad_id]"
                 )
 
+            if "advertiser_id" in dimensions:
+                dimensions.remove("advertiser_id")
+
             metrics = fields[2].replace(" ", "").split(",")
-            filters = []
+            filtering_param = False
+            filter_name = ""
+            filter_value = []
             if len(fields) == 4:
-                filters = fields[3].replace(" ", "").split(",")
+
+                def parse_filters(filters_raw: str) -> dict:
+                    # Parse filter string like "key1=value1,key2=value2,value3,value4"
+                    filters = {}
+                    current_key = None
+
+                    for item in filters_raw.split(","):
+                        if "=" in item:
+                            # Start of a new key-value pair
+                            key, value = item.split("=")
+                            filters[key] = [value]  # Always start with a list
+                            current_key = key
+                        elif current_key is not None:
+                            # Additional value for the current key
+                            filters[current_key].append(item)
+
+                    # Convert single-item lists to simple values
+                    return {k: v[0] if len(v) == 1 else v for k, v in filters.items()}
+
+                filtering_param = True
+                filters = parse_filters(fields[3])
+                if len(filters) > 1:
+                    raise ValueError(
+                        "Only one filter is allowed for TikTok custom reports"
+                    )
+                filter_name = list(filters.keys())[0]
+                filter_value = list(map(int, filters[list(filters.keys())[0]]))
+
         return tiktok_source(
             start_date=start_date,
             end_date=end_date,
             access_token=access_token[0],
-            advertiser_id=advertiser_id[0],
-            time_zone=time_zone[0],
+            advertiser_ids=advertiser_ids,
+            timezone=timezone,
             dimensions=dimensions,
             metrics=metrics,
-            filters=filters,
             page_size=page_size,
+            filter_name=filter_name,
+            filter_value=filter_value,
+            filtering_param=filtering_param,
         ).with_resources(endpoint)
 
 

ingestr/src/tiktok_ads/__init__.py

@@ -1,4 +1,4 @@
-from typing import Iterable, Optional
+from typing import Iterable
 
 import dlt
 import pendulum
@@ -8,6 +8,39 @@ from dlt.sources import DltResource
 
 from .tiktok_helpers import TikTokAPI
 
+KNOWN_TYPE_HINTS = {
+    "spend": {"data_type": "decimal"},
+    "billed_cost": {"data_type": "decimal"},
+    "cash_spend": {"data_type": "decimal"},
+    "voucher_spend": {"data_type": "decimal"},
+    "cpc": {"data_type": "decimal"},
+    "cpm": {"data_type": "decimal"},
+    "impressions": {"data_type": "bigint"},
+    "gross_impressions": {"data_type": "bigint"},
+    "clicks": {"data_type": "bigint"},
+    "ctr": {"data_type": "decimal"},
+    "reach": {"data_type": "bigint"},
+    "cost_per_1000_reached": {"data_type": "decimal"},
+    "frequency": {"data_type": "decimal"},
+    "conversion": {"data_type": "bigint"},
+    "cost_per_conversion": {"data_type": "decimal"},
+    "conversion_rate": {"data_type": "decimal"},
+    "conversion_rate_v2": {"data_type": "decimal"},
+    "real_time_conversion": {"data_type": "bigint"},
+    "real_time_cost_per_conversion": {"data_type": "decimal"},
+    "real_time_conversion_rate": {"data_type": "decimal"},
+    "real_time_conversion_rate_v2": {"data_type": "decimal"},
+    "result": {"data_type": "bigint"},
+    "cost_per_result": {"data_type": "decimal"},
+    "result_rate": {"data_type": "decimal"},
+    "real_time_result": {"data_type": "bigint"},
+    "real_time_cost_per_result": {"data_type": "decimal"},
+    "real_time_result_rate": {"data_type": "decimal"},
+    "secondary_goal_result": {"data_type": "bigint"},
+    "cost_per_secondary_goal_result": {"data_type": "decimal"},
+    "secondary_goal_result_rate": {"data_type": "decimal"},
+}
+
 
 def find_intervals(
     current_date: pendulum.DateTime,
@@ -23,42 +56,27 @@ def find_intervals(
     return intervals
 
 
-def fetch_tiktok_reports(
-    tiktok_api: TikTokAPI,
-    current_date: pendulum.DateTime,
-    interval_end: pendulum.DateTime,
-    advertiser_id: str,
-    dimensions: list[str],
-    metrics: list[str],
-    filters: Optional[dict] | None,
-) -> Iterable[TDataItem]:
-    try:
-        yield from tiktok_api.fetch_pages(
-            advertiser_id=advertiser_id,
-            start_time=current_date,
-            end_time=interval_end,
-            dimensions=dimensions,
-            metrics=metrics,
-            filters=None,
-        )
-    except Exception as e:
-        raise RuntimeError(f"Error fetching TikTok report: {e}")
-
-
 @dlt.source(max_table_nesting=0)
 def tiktok_source(
     start_date: pendulum.DateTime,
     end_date: pendulum.DateTime,
     access_token: str,
-    advertiser_id: str,
-    time_zone: str,
+    advertiser_ids: list[str],
+    timezone: str,
     page_size: int,
+    filtering_param: bool,
+    filter_name: str,
+    filter_value: list[int],
     dimensions: list[str],
     metrics: list[str],
-    filters=None,
 ) -> DltResource:
     tiktok_api = TikTokAPI(
-        access_token=access_token, time_zone=time_zone, page_size=page_size
+        access_token=access_token,
+        timezone=timezone,
+        page_size=page_size,
+        filtering_param=filtering_param,
+        filter_name=filter_name,
+        filter_value=filter_value,
     )
     incremental_loading_param = ""
     is_incremental = False
@@ -74,17 +92,34 @@ def tiktok_source(
         is_incremental = True
         interval_days = 0
 
-    @dlt.resource(write_disposition="merge", primary_key=dimensions)
+    type_hints = {
+        "advertiser_id": {"data_type": "text"},
+    }
+    for dimension in dimensions:
+        if dimension in KNOWN_TYPE_HINTS:
+            type_hints[dimension] = KNOWN_TYPE_HINTS[dimension]
+    for metric in metrics:
+        if metric in KNOWN_TYPE_HINTS:
+            type_hints[metric] = KNOWN_TYPE_HINTS[metric]
+
+    @dlt.resource(
+        write_disposition="merge",
+        primary_key=dimensions + ["advertiser_id"],
+        columns=type_hints,
+        parallelized=True,
+    )
     def custom_reports(
-        datetime=dlt.sources.incremental(incremental_loading_param, start_date)
-        if is_incremental
-        else None,
+        datetime=(
+            dlt.sources.incremental(incremental_loading_param, start_date)
+            if is_incremental
+            else None
+        ),
     ) -> Iterable[TDataItem]:
-        current_date = start_date.in_tz(time_zone)
+        current_date = start_date.in_tz(timezone)
 
         if datetime is not None:
             datetime_str = datetime.last_value
-            current_date = ensure_pendulum_datetime(datetime_str).in_tz(time_zone)
+            current_date = ensure_pendulum_datetime(datetime_str).in_tz(timezone)
 
         list_of_interval = find_intervals(
             current_date=current_date,
@@ -93,14 +128,12 @@ def tiktok_source(
         )
 
         for start, end in list_of_interval:
-            yield from fetch_tiktok_reports(
-                tiktok_api=tiktok_api,
-                current_date=start,
-                interval_end=end,
-                advertiser_id=advertiser_id,
+            yield tiktok_api.fetch_pages(
+                advertiser_ids=advertiser_ids,
+                start_time=start,
+                end_time=end,
                 dimensions=dimensions,
                 metrics=metrics,
-                filters=None,
             )
 
     return custom_reports

ingestr/src/tiktok_ads/tiktok_helpers.py

@@ -25,17 +25,17 @@ def create_client() -> requests.Session:
     ).session
 
 
-def flat_structure(items, time_zone="UTC"):
+def flat_structure(items, timezone="UTC"):
     for item in items:
         if "dimensions" in item:
             for key, value in item["dimensions"].items():
                 if key == "stat_time_day":
                     item["stat_time_day"] = ensure_pendulum_datetime(value).in_tz(
-                        time_zone
+                        timezone
                     )
                 elif key == "stat_time_hour":
                     item["stat_time_hour"] = ensure_pendulum_datetime(value).in_tz(
-                        time_zone
+                        timezone
                     )
                 else:
                     item[key] = value
@@ -49,15 +49,26 @@ def flat_structure(items, time_zone="UTC"):
 
 
 class TikTokAPI:
-    def __init__(self, access_token, time_zone, page_size):
+    def __init__(
+        self,
+        access_token,
+        timezone,
+        page_size,
+        filtering_param,
+        filter_name,
+        filter_value,
+    ):
         self.headers = {
             "Access-Token": access_token,
         }
-        self.time_zone = time_zone
+        self.timezone = timezone
         self.page_size = page_size
+        self.filtering_param = filtering_param
+        self.filter_name = filter_name
+        self.filter_value = filter_value
 
     def fetch_pages(
-        self, advertiser_id: str, start_time, end_time, dimensions, metrics, filters
+        self, advertiser_ids: list[str], start_time, end_time, dimensions, metrics
     ):
         data_level_mapping = {
             "advertiser_id": "AUCTION_ADVERTISER",
@@ -75,8 +86,15 @@ class TikTokAPI:
         start_time = ensure_pendulum_datetime(start_time).to_date_string()
         end_time = ensure_pendulum_datetime(end_time).to_date_string()
 
-        self.params = {
-            "advertiser_id": advertiser_id,
+        filtering = [
+            {
+                "field_name": self.filter_name,
+                "filter_type": "IN",
+                "filter_value": json.dumps(self.filter_value),
+            }
+        ]
+        params = {
+            "advertiser_ids": json.dumps(advertiser_ids),
             "report_type": "BASIC",
             "data_level": data_level,
             "start_date": start_time,
@@ -85,12 +103,13 @@ class TikTokAPI:
             "dimensions": json.dumps(dimensions),
             "metrics": json.dumps(metrics),
         }
+
+        if self.filtering_param:
+            params["filtering"] = json.dumps(filtering)
         client = create_client()
         while True:
-            self.params["page"] = current_page
-            response = client.get(
-                url=BASE_URL, headers=self.headers, params=self.params
-            )
+            params["page"] = current_page
+            response = client.get(url=BASE_URL, headers=self.headers, params=params)
 
             result = response.json()
             if result.get("message") != "OK":
@@ -99,7 +118,7 @@ class TikTokAPI:
             result_data = result.get("data", {})
             items = result_data.get("list", [])
 
-            flat_structure(items=items, time_zone=self.time_zone)
+            flat_structure(items=items, timezone=self.timezone)
 
             yield items
 

ingestr/src/version.py

@@ -1 +1 @@
-__version__ = "0.12.2"
+__version__ = "0.12.3"

{ingestr-0.12.2.dist-info → ingestr-0.12.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ingestr
-Version: 0.12.2
+Version: 0.12.3
 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

{ingestr-0.12.2.dist-info → ingestr-0.12.3.dist-info}/RECORD

@@ -3,10 +3,10 @@ ingestr/src/.gitignore,sha256=8cX1AZTSI0TcdZFGTmS_oyBjpfCzhOEt0DdAo2dFIY8,203
 ingestr/src/destinations.py,sha256=zcHJIIHAZmcD9sJomd6G1Bc-1KsxnBD2aByOSV_9L3g,8850
 ingestr/src/factory.py,sha256=UyE1TzTHn_V8JZno5SSYfQsho1eFYzzvOylogw4S49E,4389
 ingestr/src/filters.py,sha256=0JQXeAr2APFMnW2sd-6BlAMWv93bXV17j8b5MM8sHmM,580
-ingestr/src/sources.py,sha256=QCyfkhLl5jgmosZUeh4BTrmqHk74Vus7zLgk_MBdPhc,41096
+ingestr/src/sources.py,sha256=Jy1N5EfbxfTae0L7PiZmPVxVYWLvOuLlw3kJ6vbT50M,48027
 ingestr/src/table_definition.py,sha256=REbAbqdlmUMUuRh8nEQRreWjPVOQ5ZcfqGkScKdCrmk,390
 ingestr/src/time.py,sha256=H_Fk2J4ShXyUM-EMY7MqCLZQhlnZMZvO952bmZPc4yE,254
-ingestr/src/version.py,sha256=NJQQPiZZfrBXFMqZlsia0JrhloS2PexbdxYYUs0c2Us,23
+ingestr/src/version.py,sha256=Qu8-91hLcRe7wfW37PwNdivTonHHKLrqtJPOAq3Jvhc,23
 ingestr/src/adjust/__init__.py,sha256=NaRNwDhItG8Q7vUHw7zQvyfWjmT32M0CSc5ufjmBM9U,3067
 ingestr/src/adjust/adjust_helpers.py,sha256=-tmmxy9k3wms-ZEIgxmlp2cAQ2X_O1lgjY1128bbMu4,3224
 ingestr/src/airtable/__init__.py,sha256=GHWYrjI2qhs_JihdNJysB0Ni3bzqT_MLXn_S9_Q5zRA,2775
@@ -61,8 +61,8 @@ ingestr/src/stripe_analytics/helpers.py,sha256=iqZOyiGIOhOAhVXXU16DP0hkkTKcTrDu6
 ingestr/src/stripe_analytics/settings.py,sha256=rl9L5XumxO0pjkZf7MGesXHp4QLRgnz3RWLuDWDBKXo,380
 ingestr/src/telemetry/event.py,sha256=MpWc5tt0lSJ1pWKe9HQ11BHrcPBxSH40l4wjZi9u0tI,924
 ingestr/src/testdata/fakebqcredentials.json,sha256=scc6TUc963KAbKTLZCfcmqVzbtzDCW1_8JNRnyAXyy8,628
-ingestr/src/tiktok_ads/__init__.py,sha256=vJjVxEw3W1Rvc2QDQbox_8Ma0Cp1RT7iKsQ9MAv6Cgc,3036
-ingestr/src/tiktok_ads/tiktok_helpers.py,sha256=lY7yWl_aJh5Hj-bVvt07MHvhfvXnghaGOLhGHF5gLh4,3444
+ingestr/src/tiktok_ads/__init__.py,sha256=U4ZHPUW0c4LpKx4hjT2Lz5hgWFgwQSbAAkkYIrxYHZo,4469
+ingestr/src/tiktok_ads/tiktok_helpers.py,sha256=cfdPflCeR_mCk5fxq0v4d7pzlvZDiAoz8bWQJYqKALM,3935
 ingestr/src/zendesk/__init__.py,sha256=C7HkN195DGdOHId2_Sa_kAlcBrUmnVYZUa_tPkiyf1Q,17564
 ingestr/src/zendesk/settings.py,sha256=Vdj706nTJFQ-3KH4nO97iYCQuba3dV3E9gfnmLK6xwU,2294
 ingestr/src/zendesk/helpers/__init__.py,sha256=YTJejCiUjfIcsj9FrkY0l-JGYDI7RRte1Ydq5FDH_0c,888
@@ -77,8 +77,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.12.2.dist-info/METADATA,sha256=SAZJKqigL1ARQdv3eGX4RZVigZwYJCEcCt36lpvZtsQ,7910
-ingestr-0.12.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ingestr-0.12.2.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
-ingestr-0.12.2.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
-ingestr-0.12.2.dist-info/RECORD,,
+ingestr-0.12.3.dist-info/METADATA,sha256=Kh5v7a3mzxqmekWFp8ebU-uHKwzHRrN0HkNHPRV3_5U,7910
+ingestr-0.12.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ingestr-0.12.3.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
+ingestr-0.12.3.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
+ingestr-0.12.3.dist-info/RECORD,,