ingestr 0.13.85__py3-none-any.whl → 0.13.86__py3-none-any.whl

ingestr/src/revenuecat/__init__.py

@@ -0,0 +1,103 @@
+import asyncio
+from typing import Any, Dict, Iterable, Iterator
+
+import aiohttp
+import dlt
+
+from .helpers import (
+    _make_request,
+    _paginate,
+    convert_timestamps_to_iso,
+    process_customer_with_nested_resources_async,
+)
+
+
+@dlt.source(name="revenuecat", max_table_nesting=0)
+def revenuecat_source(
+    api_key: str,
+    project_id: str = None,
+) -> Iterable[dlt.sources.DltResource]:
+    """
+    RevenueCat source for extracting data from RevenueCat API v2.
+
+    Args:
+        api_key: RevenueCat API v2 secret key with Bearer token format
+        project_id: RevenueCat project ID (required for customers, products, subscriptions, purchases)
+
+    Returns:
+        Iterable of DLT resources for customers, products, purchases, subscriptions, and projects
+    """
+
+    @dlt.resource(name="projects", primary_key="id", write_disposition="merge")
+    def projects() -> Iterator[Dict[str, Any]]:
+        """Get list of projects."""
+        # Get projects list
+        data = _make_request(api_key, "/projects")
+        if "items" in data:
+            for project in data["items"]:
+                project = convert_timestamps_to_iso(project, ["created_at"])
+                yield project
+
+    @dlt.resource(
+        name="customers", primary_key="id", write_disposition="merge", parallelized=True
+    )
+    def customers() -> Iterator[Dict[str, Any]]:
+        """Get list of customers with nested purchases and subscriptions."""
+        if project_id is None:
+            raise ValueError("project_id is required for customers resource")
+        endpoint = f"/projects/{project_id}/customers"
+
+        async def process_customer_batch(customer_batch):
+            """Process a batch of customers with async operations."""
+            async with aiohttp.ClientSession() as session:
+                tasks = []
+                for customer in customer_batch:
+                    task = process_customer_with_nested_resources_async(
+                        session, api_key, project_id, customer
+                    )
+                    tasks.append(task)
+
+                return await asyncio.gather(*tasks)
+
+        def process_customers_sync():
+            """Process customers in batches using asyncio."""
+            batch_size = 50  # Conservative batch size due to 60 req/min rate limit
+            current_batch = []
+
+            for customer in _paginate(api_key, endpoint):
+                current_batch.append(customer)
+
+                if len(current_batch) >= batch_size:
+                    # Process the batch asynchronously
+                    processed_customers = asyncio.run(
+                        process_customer_batch(current_batch)
+                    )
+                    for processed_customer in processed_customers:
+                        yield processed_customer
+                    current_batch = []
+
+            # Process any remaining customers in the final batch
+            if current_batch:
+                processed_customers = asyncio.run(process_customer_batch(current_batch))
+                for processed_customer in processed_customers:
+                    yield processed_customer
+
+        # Yield each processed customer
+        yield from process_customers_sync()
+
+    @dlt.resource(name="products", primary_key="id", write_disposition="merge")
+    def products() -> Iterator[Dict[str, Any]]:
+        """Get list of products."""
+        if project_id is None:
+            raise ValueError("project_id is required for products resource")
+        endpoint = f"/projects/{project_id}/products"
+
+        for product in _paginate(api_key, endpoint):
+            product = convert_timestamps_to_iso(product, ["created_at", "updated_at"])
+            yield product
+
+    return [
+        projects,
+        customers,
+        products,
+    ]

ingestr/src/revenuecat/helpers.py

@@ -0,0 +1,262 @@
+import asyncio
+import time
+from typing import Any, Dict, Iterator, List, Optional
+
+import aiohttp
+import pendulum
+import requests
+
+REVENUECAT_API_BASE = "https://api.revenuecat.com/v2"
+
+
+def _make_request(
+    api_key: str,
+    endpoint: str,
+    params: Optional[Dict[str, Any]] = None,
+    max_retries: int = 3,
+) -> Dict[str, Any]:
+    """Make a REST API request to RevenueCat API v2 with rate limiting."""
+    auth_header = f"Bearer {api_key}"
+
+    headers = {"Authorization": auth_header, "Content-Type": "application/json"}
+
+    url = f"{REVENUECAT_API_BASE}{endpoint}"
+
+    for attempt in range(max_retries + 1):
+        try:
+            response = requests.get(url, headers=headers, params=params or {})
+
+            # Handle rate limiting (429 Too Many Requests)
+            if response.status_code == 429:
+                if attempt < max_retries:
+                    # Wait based on Retry-After header or exponential backoff
+                    retry_after = response.headers.get("Retry-After")
+                    if retry_after:
+                        wait_time = int(retry_after)
+                    else:
+                        wait_time = (2**attempt) * 5  # 5, 10, 20 seconds
+
+                    time.sleep(wait_time)
+                    continue
+
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.RequestException:
+            if attempt < max_retries:
+                wait_time = (2**attempt) * 2  # 2, 4, 8 seconds
+                time.sleep(wait_time)
+                continue
+            raise
+
+    # If we get here, all retries failed
+    response.raise_for_status()
+    return response.json()
+
+
+def _paginate(
+    api_key: str, endpoint: str, params: Optional[Dict[str, Any]] = None
+) -> Iterator[Dict[str, Any]]:
+    """Paginate through RevenueCat API results."""
+    current_params = params.copy() if params is not None else {}
+    current_params["limit"] = 1000
+
+    while True:
+        data = _make_request(api_key, endpoint, current_params)
+
+        # Yield items from the current page
+        if "items" in data and data["items"] is not None:
+            for item in data["items"]:
+                yield item
+
+        # Check if there's a next page
+        if "next_page" not in data:
+            break
+
+        # Extract starting_after parameter from next_page URL
+        next_page_url = data["next_page"]
+        if next_page_url and "starting_after=" in next_page_url:
+            starting_after = next_page_url.split("starting_after=")[1].split("&")[0]
+            current_params["starting_after"] = starting_after
+        else:
+            break
+
+
+def convert_timestamps_to_iso(
+    record: Dict[str, Any], timestamp_fields: List[str]
+) -> Dict[str, Any]:
+    """Convert timestamp fields from milliseconds to ISO format."""
+    for field in timestamp_fields:
+        if field in record and record[field] is not None:
+            # Convert from milliseconds timestamp to ISO datetime string
+            timestamp_ms = record[field]
+            dt = pendulum.from_timestamp(timestamp_ms / 1000)
+            record[field] = dt.to_iso8601_string()
+
+    return record
+
+
+async def _make_request_async(
+    session: aiohttp.ClientSession,
+    api_key: str,
+    endpoint: str,
+    params: Optional[Dict[str, Any]] = None,
+    max_retries: int = 3,
+) -> Dict[str, Any]:
+    """Make an async REST API request to RevenueCat API v2 with rate limiting."""
+    auth_header = f"Bearer {api_key}"
+
+    headers = {"Authorization": auth_header, "Content-Type": "application/json"}
+
+    url = f"{REVENUECAT_API_BASE}{endpoint}"
+
+    for attempt in range(max_retries + 1):
+        try:
+            async with session.get(
+                url, headers=headers, params=params or {}
+            ) as response:
+                # Handle rate limiting (429 Too Many Requests)
+                if response.status == 429:
+                    if attempt < max_retries:
+                        # Wait based on Retry-After header or exponential backoff
+                        retry_after = response.headers.get("Retry-After")
+                        if retry_after:
+                            wait_time = int(retry_after)
+                        else:
+                            wait_time = (2**attempt) * 5  # 5, 10, 20 seconds
+
+                        await asyncio.sleep(wait_time)
+                        continue
+
+                response.raise_for_status()
+                return await response.json()
+
+        except aiohttp.ClientError:
+            if attempt < max_retries:
+                wait_time = (2**attempt) * 2  # 2, 4, 8 seconds
+                await asyncio.sleep(wait_time)
+                continue
+            raise
+
+    # If we get here, all retries failed
+    async with session.get(url, headers=headers, params=params or {}) as response:
+        response.raise_for_status()
+        return await response.json()
+
+
+async def _paginate_async(
+    session: aiohttp.ClientSession,
+    api_key: str,
+    endpoint: str,
+    params: Optional[Dict[str, Any]] = None,
+) -> List[Dict[str, Any]]:
+    """Paginate through RevenueCat API results asynchronously."""
+    items = []
+    current_params = params.copy() if params is not None else {}
+    current_params["limit"] = 1000
+
+    while True:
+        data = await _make_request_async(session, api_key, endpoint, current_params)
+
+        # Collect items from the current page
+        if "items" in data and data["items"] is not None:
+            items.extend(data["items"])
+
+        # Check if there's a next page
+        if "next_page" not in data:
+            break
+
+        # Extract starting_after parameter from next_page URL
+        next_page_url = data["next_page"]
+        if next_page_url and "starting_after=" in next_page_url:
+            starting_after = next_page_url.split("starting_after=")[1].split("&")[0]
+            current_params["starting_after"] = starting_after
+        else:
+            break
+
+    return items
+
+
+async def fetch_and_process_nested_resource_async(
+    session: aiohttp.ClientSession,
+    api_key: str,
+    project_id: str,
+    customer_id: str,
+    customer: Dict[str, Any],
+    resource_name: str,
+    timestamp_fields: Optional[List[str]] = None,
+) -> None:
+    """
+    Fetch and process any nested resource for a customer asynchronously.
+
+    Args:
+        session: aiohttp ClientSession
+        api_key: RevenueCat API key
+        project_id: Project ID
+        customer_id: Customer ID
+        customer: Customer data dictionary to modify
+        resource_name: Name of the nested resource (e.g., 'purchases', 'subscriptions', 'events')
+        timestamp_fields: List of timestamp fields to convert to ISO format
+    """
+    # If resource not included in customer data, fetch separately
+    if resource_name not in customer or customer[resource_name] is None:
+        endpoint = f"/projects/{project_id}/customers/{customer_id}/{resource_name}"
+        customer[resource_name] = await _paginate_async(session, api_key, endpoint)
+
+    # Convert timestamps if fields specified
+    if (
+        timestamp_fields
+        and resource_name in customer
+        and customer[resource_name] is not None
+    ):
+        for item in customer[resource_name]:
+            convert_timestamps_to_iso(item, timestamp_fields)
+
+
+async def process_customer_with_nested_resources_async(
+    session: aiohttp.ClientSession,
+    api_key: str,
+    project_id: str,
+    customer: Dict[str, Any],
+) -> Dict[str, Any]:
+    """
+    Process a customer and fetch nested resources concurrently.
+
+    Args:
+        session: aiohttp ClientSession
+        api_key: RevenueCat API key
+        project_id: Project ID
+        customer: Customer data to process
+
+    Returns:
+        Customer data with nested resources populated
+    """
+    customer_id = customer["id"]
+
+    # Convert customer timestamps
+    customer = convert_timestamps_to_iso(customer, ["first_seen_at", "last_seen_at"])
+
+    # Define nested resources to fetch concurrently
+    nested_resources = [
+        ("subscriptions", ["purchased_at", "expires_at", "grace_period_expires_at"]),
+        ("purchases", ["purchased_at", "expires_at"]),
+    ]
+
+    # Create concurrent tasks for fetching nested resources
+    tasks = []
+    for resource_name, timestamp_fields in nested_resources:
+        task = fetch_and_process_nested_resource_async(
+            session,
+            api_key,
+            project_id,
+            customer_id,
+            customer,
+            resource_name,
+            timestamp_fields,
+        )
+        tasks.append(task)
+
+    # Wait for all nested resources to be fetched
+    await asyncio.gather(*tasks)
+
+    return customer

ingestr/src/sources.py

@@ -1054,9 +1054,10 @@ class FacebookAdsSource:
                 )
 
             # Validate breakdown type against available options from settings
-            import typing
 
-            from ingestr.src.facebook_ads.helpers import parse_insights_table_to_source_kwargs
+            from ingestr.src.facebook_ads.helpers import (
+                parse_insights_table_to_source_kwargs,
+            )
 
             source_kwargs = {
                 "access_token": access_token[0],
@@ -2689,13 +2690,13 @@ class FrankfurterSource:
 
         if kwargs.get("interval_start"):
             start_date = ensure_pendulum_datetime(str(kwargs.get("interval_start")))
-            if kwargs.get("interval_end"):
-                end_date = ensure_pendulum_datetime(str(kwargs.get("interval_end")))
-            else:
-                end_date = pendulum.now()
         else:
-            start_date = pendulum.now()
-            end_date = pendulum.now()
+            start_date = pendulum.yesterday()
+
+        if kwargs.get("interval_end"):
+            end_date = ensure_pendulum_datetime(str(kwargs.get("interval_end")))
+        else:
+            end_date = None
 
         validate_dates(start_date=start_date, end_date=end_date)
 
@@ -3224,6 +3225,76 @@ class PinterestSource:
         ).with_resources(table)
 
 
+class FluxxSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        if kwargs.get("incremental_key"):
+            raise ValueError(
+                "Fluxx takes care of incrementality on its own, you should not provide incremental_key"
+            )
+
+        # Parse URI: fluxx://instance?client_id=xxx&client_secret=xxx
+        parsed_uri = urlparse(uri)
+        source_params = parse_qs(parsed_uri.query)
+
+        instance = parsed_uri.hostname
+        if not instance:
+            raise ValueError(
+                "Instance is required in the URI (e.g., fluxx://mycompany.preprod)"
+            )
+
+        client_id = source_params.get("client_id")
+        if not client_id:
+            raise ValueError("client_id in the URI is required to connect to Fluxx")
+
+        client_secret = source_params.get("client_secret")
+        if not client_secret:
+            raise ValueError("client_secret in the URI is required to connect to Fluxx")
+
+        # Parse date parameters
+        start_date = kwargs.get("interval_start")
+        if start_date:
+            start_date = ensure_pendulum_datetime(start_date)
+
+        end_date = kwargs.get("interval_end")
+        if end_date:
+            end_date = ensure_pendulum_datetime(end_date)
+
+        # Import Fluxx source
+        from ingestr.src.fluxx import fluxx_source
+
+        # Parse table specification for custom column selection
+        # Format: "resource_name:field1,field2,field3" or "resource_name"
+        resources = None
+        custom_fields = {}
+
+        if table:
+            # Handle single resource with custom fields or multiple resources
+            if ":" in table and table.count(":") == 1:
+                # Single resource with custom fields: "grant_request:id,name,amount"
+                resource_name, field_list = table.split(":", 1)
+                resource_name = resource_name.strip()
+                fields = [f.strip() for f in field_list.split(",")]
+                resources = [resource_name]
+                custom_fields[resource_name] = fields
+            else:
+                # Multiple resources or single resource without custom fields
+                # Support comma-separated list: "grant_request,user"
+                resources = [r.strip() for r in table.split(",")]
+
+        return fluxx_source(
+            instance=instance,
+            client_id=client_id[0],
+            client_secret=client_secret[0],
+            start_date=start_date,
+            end_date=end_date,
+            resources=resources,
+            custom_fields=custom_fields,
+        )
+
+
 class LinearSource:
     def handles_incrementality(self) -> bool:
         return True
@@ -3241,11 +3312,11 @@ class LinearSource:
             raise MissingValueError("api_key", "Linear")
 
         if table not in [
-            "issues", 
-            "projects", 
-            "teams", 
-            "users", 
-            "workflow_states", 
+            "issues",
+            "projects",
+            "teams",
+            "users",
+            "workflow_states",
             "cycles",
             "attachments",
             "comments",
@@ -3282,6 +3353,54 @@ class LinearSource:
         ).with_resources(table)
 
 
+class RevenueCatSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        if kwargs.get("incremental_key"):
+            raise ValueError(
+                "RevenueCat takes care of incrementality on its own, you should not provide incremental_key"
+            )
+
+        parsed_uri = urlparse(uri)
+        params = parse_qs(parsed_uri.query)
+
+        api_key = params.get("api_key")
+        if api_key is None:
+            raise MissingValueError("api_key", "RevenueCat")
+
+        project_id = params.get("project_id")
+        if project_id is None and table != "projects":
+            raise MissingValueError("project_id", "RevenueCat")
+
+        if table not in [
+            "customers",
+            "products",
+            "subscriptions",
+            "purchases",
+            "projects",
+        ]:
+            raise UnsupportedResourceError(table, "RevenueCat")
+
+        start_date = kwargs.get("interval_start")
+        if start_date is not None:
+            start_date = ensure_pendulum_datetime(start_date)
+        else:
+            start_date = pendulum.datetime(2020, 1, 1).in_tz("UTC")
+
+        end_date = kwargs.get("interval_end")
+        if end_date is not None:
+            end_date = ensure_pendulum_datetime(end_date).in_tz("UTC")
+
+        from ingestr.src.revenuecat import revenuecat_source
+
+        return revenuecat_source(
+            api_key=api_key[0],
+            project_id=project_id[0] if project_id is not None else None,
+        ).with_resources(table)
+
+
 class ZoomSource:
     def handles_incrementality(self) -> bool:
         return True

ingestr/src/stripe_analytics/__init__.py

@@ -101,23 +101,6 @@ def incremental_stripe_source(
     initial_start_date: Optional[DateTime] = None,
     end_date: Optional[DateTime] = None,
 ) -> Iterable[DltResource]:
-    """
-    As Stripe API does not include the "updated" key in its responses,
-    we are only able to perform incremental downloads from endpoints where all objects are uneditable.
-    This source yields the resources with incremental loading based on "append" mode.
-    You will load only the newest data without duplicating and without downloading a huge amount of data each time.
-
-    Args:
-        endpoints (tuple): A tuple of endpoint names to retrieve data from. Defaults to Stripe API endpoints with uneditable data.
-        stripe_secret_key (str): The API access token for authentication. Defaults to the value in the `dlt.secrets` object.
-        initial_start_date (Optional[DateTime]): An optional parameter that specifies the initial value for dlt.sources.incremental.
-                            If parameter is not None, then load only data that were created after initial_start_date on the first run.
-                            Defaults to None. Format: datetime(YYYY, MM, DD).
-        end_date (Optional[DateTime]): An optional end date to limit the data retrieved.
-                  Defaults to None. Format: datetime(YYYY, MM, DD).
-    Returns:
-        Iterable[DltResource]: Resources with only that data has not yet been loaded.
-    """
     stripe.api_key = stripe_secret_key
     stripe.api_version = "2022-11-15"
     start_date_unix = (
@@ -142,6 +125,6 @@ def incremental_stripe_source(
         yield dlt.resource(
             incremental_resource,
             name=endpoint,
-            write_disposition="append",
+            write_disposition="merge",
             primary_key="id",
         )(endpoint)

{ingestr-0.13.85.dist-info → ingestr-0.13.86.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ingestr
-Version: 0.13.85
+Version: 0.13.86
 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.13.85.dist-info → ingestr-0.13.86.dist-info}/RECORD

@@ -2,16 +2,16 @@ ingestr/conftest.py,sha256=OE2yxeTCosS9CUFVuqNypm-2ftYvVBeeq7egm3878cI,1981
 ingestr/main.py,sha256=qoWHNcHh0-xVnyQxbQ-SKuTxPb1RNV3ENkCpqO7CLrk,26694
 ingestr/src/.gitignore,sha256=8cX1AZTSI0TcdZFGTmS_oyBjpfCzhOEt0DdAo2dFIY8,203
 ingestr/src/blob.py,sha256=UUWMjHUuoR9xP1XZQ6UANQmnMVyDx3d0X4-2FQC271I,2138
-ingestr/src/buildinfo.py,sha256=8R_qSk4KmqC0NReX2RH71MpXDTrSB4tdbtvR1yvLRcA,21
+ingestr/src/buildinfo.py,sha256=Sau1WKfATfGbfhYBf36HIMjBxy3Ri3NHPH1bcv0qOvU,21
 ingestr/src/destinations.py,sha256=M2Yni6wiWcrvZ8EPJemidqxN156l0rehgCc7xuil7mo,22840
 ingestr/src/errors.py,sha256=Ufs4_DfE77_E3vnA1fOQdi6cmuLVNm7_SbFLkL1XPGk,686
-ingestr/src/factory.py,sha256=SQr7s-WCx_jL8DmPbeCc4VuE35z1J7gCAwKGAkOpv2M,6836
+ingestr/src/factory.py,sha256=hC5E_XgrgTHMqwqPc6ihUYvRGTGMTzdPfQhrgPyD0tY,6945
 ingestr/src/filters.py,sha256=LLecXe9QkLFkFLUZ92OXNdcANr1a8edDxrflc2ko_KA,1452
 ingestr/src/http_client.py,sha256=bxqsk6nJNXCo-79gW04B53DQO-yr25vaSsqP0AKtjx4,732
 ingestr/src/loader.py,sha256=9NaWAyfkXdqAZSS-N72Iwo36Lbx4PyqIfaaH1dNdkFs,1712
 ingestr/src/partition.py,sha256=BrIP6wFJvyR7Nus_3ElnfxknUXeCipK_E_bB8kZowfc,969
 ingestr/src/resource.py,sha256=ZqmZxFQVGlF8rFPhBiUB08HES0yoTj8sZ--jKfaaVps,1164
-ingestr/src/sources.py,sha256=NfD7pj0WOD1wQOV3oZkHmGOAwHMuCCO_Mzf8F8EpobU,120918
+ingestr/src/sources.py,sha256=CMXQRJlbHcGwKtrD-nt_ov-UlAn5UOQe08cdc7Wzel4,125068
 ingestr/src/table_definition.py,sha256=REbAbqdlmUMUuRh8nEQRreWjPVOQ5ZcfqGkScKdCrmk,390
 ingestr/src/time.py,sha256=H_Fk2J4ShXyUM-EMY7MqCLZQhlnZMZvO952bmZPc4yE,254
 ingestr/src/version.py,sha256=J_2xgZ0mKlvuHcjdKCx2nlioneLH0I47JiU_Slr_Nwc,189
@@ -49,8 +49,10 @@ ingestr/src/facebook_ads/utils.py,sha256=ES2ylPoW3j3fjp6OMUgp21n1cG1OktXsmWWMk5v
 ingestr/src/filesystem/__init__.py,sha256=zkIwbRr0ir0EUdniI25p2zGiVc-7M9EmR351AjNb0eA,4163
 ingestr/src/filesystem/helpers.py,sha256=bg0muSHZr3hMa8H4jN2-LGWzI-SUoKlQNiWJ74-YYms,3211
 ingestr/src/filesystem/readers.py,sha256=a0fKkaRpnAOGsXI3EBNYZa7x6tlmAOsgRzb883StY30,3987
-ingestr/src/frankfurter/__init__.py,sha256=oVi4BiOxPRyckEVrBNunyMAHulPyMgyGRwBbhn-Xz6M,4987
-ingestr/src/frankfurter/helpers.py,sha256=SyrkRTDqvKdQxRHTV5kcSeVG3FEnaK5zxHyNyqtumZ0,1445
+ingestr/src/fluxx/__init__.py,sha256=Ei8BE0KAEzpadJT9RO5-8zMA7LvnIPhNPDKF4EyBcLo,328980
+ingestr/src/fluxx/helpers.py,sha256=dCNgvMMTSEO4LNp6luNZ-XrV4NPW-_OUfmp0k3jFhuc,6602
+ingestr/src/frankfurter/__init__.py,sha256=z98RblQx1ab2GFowDq4l5xdnv-sLb41MPGitH-y2ahc,5242
+ingestr/src/frankfurter/helpers.py,sha256=tEtx9VU7IchRmtKRIEq_r8MclNVs8vL4E_RjGW2ZSh0,1504
 ingestr/src/freshdesk/__init__.py,sha256=ukyorgCNsW_snzsYBDsr3Q0WB8f-to9Fk0enqHHFQlk,3087
 ingestr/src/freshdesk/freshdesk_client.py,sha256=1nFf0K4MQ0KZbWwk4xSbYHaykVqmPLfN39miOFDpWVc,4385
 ingestr/src/freshdesk/settings.py,sha256=0Wr_OMnUZcTlry7BmALssLxD2yh686JW4moLNv12Jnw,409
@@ -85,8 +87,8 @@ ingestr/src/kinesis/helpers.py,sha256=SO2cFmWNGcykUYmjHdfxWsOQSkLQXyhFtfWnkcUOM0
 ingestr/src/klaviyo/__init__.py,sha256=o_noUgbxLk36s4f9W56_ibPorF0n7kVapPUlV0p-jfA,7875
 ingestr/src/klaviyo/client.py,sha256=tPj79ia7AW0ZOJhzlKNPCliGbdojRNwUFp8HvB2ym5s,7434
 ingestr/src/klaviyo/helpers.py,sha256=_i-SHffhv25feLDcjy6Blj1UxYLISCwVCMgGtrlnYHk,496
-ingestr/src/linear/__init__.py,sha256=f0f9MBEV3tK-tTT2DUOj-0-xl2QRJs1x0nYv2Lo1FZQ,12277
-ingestr/src/linear/helpers.py,sha256=pPqtJrY3D3U2IaqTsD6ChvwMLYiUVtmQ8wTvetz5U7A,3640
+ingestr/src/linear/__init__.py,sha256=rufjwhLip7RK6j2DpFzCRQEvA_oOqgPEEdREJkc53_U,12295
+ingestr/src/linear/helpers.py,sha256=J9lTuu8rHHM3YTA082_wfvByW6Teie4_44eYaVmDBhQ,3683
 ingestr/src/linkedin_ads/__init__.py,sha256=CAPWFyV24loziiphbLmODxZUXZJwm4JxlFkr56q0jfo,1855
 ingestr/src/linkedin_ads/dimension_time_enum.py,sha256=EmHRdkFyTAfo4chGjThrwqffWJxmAadZMbpTvf0xkQc,198
 ingestr/src/linkedin_ads/helpers.py,sha256=eUWudRVlXl4kqIhfXQ1eVsUpZwJn7UFqKSpnbLfxzds,4498
@@ -111,6 +113,8 @@ ingestr/src/pipedrive/helpers/__init__.py,sha256=UX1K_qnGXB0ShtnBOfp2XuVbK8RRoCK
 ingestr/src/pipedrive/helpers/custom_fields_munger.py,sha256=rZ4AjdITHfJE2NNomCR7vMBS1KnWpEGVF6fADwsIHUE,4488
 ingestr/src/pipedrive/helpers/pages.py,sha256=Klpjw2OnMuhzit3PpiHKsfzGcJ3rQPSQBl3HhE3-6eA,3358
 ingestr/src/quickbooks/__init__.py,sha256=cZUuVCOTGPHTscRj6i0DytO63_fWF-4ieMxoU4PcyTg,3727
+ingestr/src/revenuecat/__init__.py,sha256=HrI4Ht8PWTHiBYphAO26tK-2S-z1FuSIq97wu7erPIw,3785
+ingestr/src/revenuecat/helpers.py,sha256=ntdorpAdPoPBcga1fifFeAl07rKZ-CnF5u5QiFdHbW8,8664
 ingestr/src/salesforce/__init__.py,sha256=2hik5pRrxVODdDTlUEMoyccNC07zozjnxkMHcjMT1qA,4558
 ingestr/src/salesforce/helpers.py,sha256=QTdazBt-qRTBbCQMZnyclIaDQFmBixBy_RDKD00Lt-8,2492
 ingestr/src/shopify/__init__.py,sha256=dp6Ybk5LIKA5suzVt923v5LzHz5rMUuDfhjTNPqSjAc,62603
@@ -125,7 +129,7 @@ ingestr/src/solidgate/__init__.py,sha256=Ts83j-JSnFsFuF4tDhVOfZKg7H0-bIpfn3kg1ZO
 ingestr/src/solidgate/helpers.py,sha256=mAsW_1hpD7ab3Y2vw8fxHi4yD3aT1geLdIYZ7ycyxBc,5690
 ingestr/src/sql_database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ingestr/src/sql_database/callbacks.py,sha256=sEFFmXxAURY3yeBjnawigDtq9LBCvi8HFqG4kLd7tMU,2002
-ingestr/src/stripe_analytics/__init__.py,sha256=6c4zNY5CgmyjbEF94Ch8zUefdl_w8sLI3FjHUyPcC2U,6406
+ingestr/src/stripe_analytics/__init__.py,sha256=smTK8aqRsGnSdGdQAyyuItWT_k9CPKdlnTGh5DRCcDg,5144
 ingestr/src/stripe_analytics/helpers.py,sha256=KGtRcSrhKEqzJ3AWpgDV2o4cuBFaIwu2Gc1KgvVWTtg,11764
 ingestr/src/stripe_analytics/settings.py,sha256=xt1-ljwP4nLTNUa8l3KwFbtK8FtQHgHpzGF5uPKfRsw,2246
 ingestr/src/telemetry/event.py,sha256=W7bs4uVfPakQ5otmiqgqu1l5SqjYx1p87wudnWXckBc,949
@@ -153,8 +157,8 @@ ingestr/testdata/merge_expected.csv,sha256=DReHqWGnQMsf2PBv_Q2pfjsgvikYFnf1zYcQZ
 ingestr/testdata/merge_part1.csv,sha256=Pw8Z9IDKcNU0qQHx1z6BUf4rF_-SxKGFOvymCt4OY9I,185
 ingestr/testdata/merge_part2.csv,sha256=T_GiWxA81SN63_tMOIuemcvboEFeAmbKc7xRXvL9esw,287
 ingestr/tests/unit/test_smartsheets.py,sha256=eiC2CCO4iNJcuN36ONvqmEDryCA1bA1REpayHpu42lk,5058
-ingestr-0.13.85.dist-info/METADATA,sha256=N2Ry0lJc07fkSUuBUG6QuqaWlgmeClzGZZQkWrohu8I,15182
-ingestr-0.13.85.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-ingestr-0.13.85.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
-ingestr-0.13.85.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
-ingestr-0.13.85.dist-info/RECORD,,
+ingestr-0.13.86.dist-info/METADATA,sha256=EYqj1B1PK2F2EGHKmzuoxvQRSdXZThmlL0UutcFxzeo,15182
+ingestr-0.13.86.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ingestr-0.13.86.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
+ingestr-0.13.86.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
+ingestr-0.13.86.dist-info/RECORD,,