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

ingestr/src/google_analytics/helpers/__init__.py

@@ -0,0 +1,70 @@
+"""Google analytics source helpers"""
+
+from typing import Iterator, List
+
+import dlt
+from apiclient.discovery import Resource  # type: ignore
+from dlt.common import logger, pendulum
+from dlt.common.typing import TDataItem
+from google.analytics.data_v1beta.types import (
+    Dimension,
+    Metric,
+)
+from pendulum.datetime import DateTime
+
+from .data_processing import get_report
+
+
+def basic_report(
+    client: Resource,
+    rows_per_page: int,
+    dimensions: List[str],
+    metrics: List[str],
+    property_id: int,
+    resource_name: str,
+    start_date: str,
+    last_date: dlt.sources.incremental[DateTime],
+) -> Iterator[TDataItem]:
+    """
+    Retrieves the data for a report given dimensions, metrics, and filters required for the report.
+
+    Args:
+        client: The Google Analytics client used to make requests.
+        dimensions: Dimensions for the report. See metadata for the full list of dimensions.
+        metrics: Metrics for the report. See metadata for the full list of metrics.
+        property_id: A reference to the Google Analytics project.
+            More info: https://developers.google.com/analytics/devguides/reporting/data/v1/property-id
+        rows_per_page: Controls how many rows are retrieved per page in the reports.
+            Default is 10000, maximum possible is 100000.
+        resource_name: The resource name used to save incremental into dlt state.
+        start_date: Incremental load start_date.
+            Default is taken from dlt state if it exists.
+        last_date: Incremental load end date.
+            Default is taken from dlt state if it exists.
+
+    Returns:
+        Generator of all rows of data in the report.
+    """
+
+    # grab the start time from last dlt load if not filled, if that is also empty then use the first day of the millennium as the start time instead
+    if last_date.last_value:
+        if start_date != "2015-08-14":
+            logger.warning(
+                f"Using the starting date: {last_date.last_value} for incremental report: {resource_name} and ignoring start date passed as argument {start_date}"
+            )
+        start_date = last_date.last_value.to_date_string()
+    else:
+        start_date = start_date or "2015-08-14"
+
+    processed_response = get_report(
+        client=client,
+        property_id=property_id,
+        # fill dimensions and metrics with the proper api client objects
+        dimension_list=[Dimension(name=dimension) for dimension in dimensions],
+        metric_list=[Metric(name=metric) for metric in metrics],
+        limit=rows_per_page,
+        start_date=start_date,
+        # configure end_date to yesterday as a date string
+        end_date=pendulum.now().to_date_string(),
+    )
+    yield from processed_response

ingestr/src/google_analytics/helpers/data_processing.py

@@ -0,0 +1,176 @@
+"""
+This module contains helpers that process data and make it ready for loading into the database
+"""
+
+import json
+from typing import Any, Iterator, List, Union
+
+import proto
+from dlt.common.exceptions import MissingDependencyException
+from dlt.common.pendulum import pendulum
+from dlt.common.typing import DictStrAny, TDataItem, TDataItems
+
+try:
+    from google.analytics.data_v1beta import BetaAnalyticsDataClient  # noqa: F401
+    from google.analytics.data_v1beta.types import (
+        DateRange,
+        Dimension,
+        DimensionExpression,  # noqa: F401
+        DimensionMetadata,  # noqa: F401
+        GetMetadataRequest,  # noqa: F401
+        Metadata,  # noqa: F401
+        Metric,
+        MetricMetadata,  # noqa: F401
+        MetricType,
+        RunReportRequest,
+        RunReportResponse,
+    )
+except ImportError:
+    raise MissingDependencyException(
+        "Google Analytics API Client", ["google-analytics-data"]
+    )
+try:
+    from apiclient.discovery import Resource, build  # type: ignore # noqa: F401
+except ImportError:
+    raise MissingDependencyException("Google API Client", ["google-api-python-client"])
+
+
+def to_dict(item: Any) -> Iterator[TDataItem]:
+    """
+    Processes a batch result (page of results per dimension) accordingly
+    :param batch:
+    :return:
+    """
+    item = json.loads(
+        proto.Message.to_json(
+            item,
+            preserving_proto_field_name=True,
+            use_integers_for_enums=False,
+            including_default_value_fields=False,
+        )
+    )
+    yield item
+
+
+def get_report(
+    client: Resource,
+    property_id: int,
+    dimension_list: List[Dimension],
+    metric_list: List[Metric],
+    limit: int,
+    start_date: str,
+    end_date: str,
+) -> Iterator[TDataItem]:
+    """
+    Gets all the possible pages of reports with the given query parameters.
+    Processes every page and yields a dictionary for every row of the report.
+
+    Args:
+        client: The Google Analytics client used to make requests.
+        property_id: A reference to the Google Analytics project.
+            More info: https://developers.google.com/analytics/devguides/reporting/data/v1/property-id
+        dimension_list: A list of all the dimensions requested in the query.
+        metric_list: A list of all the metrics requested in the query.
+        limit: Describes how many rows there should be per page.
+        start_date: The starting date of the query.
+        end_date: The ending date of the query.
+
+    Yields:
+        Generator of all rows of data in the report.
+    """
+
+    request = RunReportRequest(
+        property=f"properties/{property_id}",
+        dimensions=dimension_list,
+        metrics=metric_list,
+        limit=limit,
+        date_ranges=[DateRange(start_date=start_date, end_date=end_date)],
+    )
+    # process request
+    response = client.run_report(request)
+    processed_response_generator = process_report(response=response)
+    yield from processed_response_generator
+
+
+def process_report(response: RunReportResponse) -> Iterator[TDataItems]:
+    """
+    Receives a single page for a report response, processes it, and returns a generator for every row of data in the report page.
+
+    Args:
+        response: The API response for a single page of the report.
+
+    Yields:
+        Generator of dictionaries for every row of the report page.
+    """
+
+    metrics_headers = [header.name for header in response.metric_headers]
+    dimensions_headers = [header.name for header in response.dimension_headers]
+
+    distinct_key_combinations = {}
+
+    for row in response.rows:
+        response_dict: DictStrAny = {
+            dimension_header: _resolve_dimension_value(
+                dimension_header, dimension_value.value
+            )
+            for dimension_header, dimension_value in zip(
+                dimensions_headers, row.dimension_values
+            )
+        }
+
+        for i in range(len(metrics_headers)):
+            # get metric type and process the value depending on type. Save metric name including type as well for the columns
+            metric_type = response.metric_headers[i].type_
+            metric_value = process_metric_value(
+                metric_type=metric_type, value=row.metric_values[i].value
+            )
+            response_dict[metrics_headers[i]] = metric_value
+
+        unique_key = "-".join(list(response_dict.keys()))
+        if unique_key not in distinct_key_combinations:
+            distinct_key_combinations[unique_key] = True
+
+        yield response_dict
+
+
+def process_metric_value(metric_type: MetricType, value: str) -> Union[str, int, float]:
+    """
+    Processes the metric type, converts it from string to the correct type, and returns it.
+
+    Args:
+        metric_type: The type of the metric.
+        value: The value of the metric as a string.
+
+    Returns:
+        The given value converted to the correct data type.
+    """
+
+    # So far according to GA4 documentation these are the correct types: https://developers.google.com/analytics/devguides/reporting/data/v1/rest/v1beta/MetricType
+    # 0 for strings, 1 for ints and 2-12 are different types of floating points.
+    if metric_type.value == 0:
+        return value
+    elif metric_type.value == 1:
+        return int(value)
+    else:
+        return float(value)
+
+
+def _resolve_dimension_value(dimension_name: str, dimension_value: str) -> Any:
+    """
+    Helper function that receives a dimension's name and value and converts it to a datetime object if needed.
+
+    Args:
+        dimension_name: Name of the dimension.
+        dimension_value: Value of the dimension.
+
+    Returns:
+        The value of the dimension with the correct data type.
+    """
+    if dimension_name == "date":
+        return pendulum.from_format(dimension_value, "YYYYMMDD", tz="UTC")
+    elif dimension_name == "dateHour":
+        return pendulum.from_format(dimension_value, "YYYYMMDDHH", tz="UTC")
+    elif dimension_name == "dateHourMinute":
+        return pendulum.from_format(dimension_value, "YYYYMMDDHHmm", tz="UTC")
+    else:
+        return dimension_value

ingestr/src/sources.py

@@ -18,7 +18,6 @@ from urllib.parse import ParseResult, parse_qs, quote, urlparse
 
 import dlt
 import pendulum
-import sqlalchemy
 from dlt.common.configuration.specs import (
     AwsCredentials,
 )
@@ -29,7 +28,9 @@ from dlt.common.libs.sql_alchemy import (
 from dlt.common.time import ensure_pendulum_datetime
 from dlt.common.typing import TDataItem, TSecretStrValue
 from dlt.extract import Incremental
-from dlt.sources.credentials import ConnectionStringCredentials
+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 (
@@ -40,7 +41,6 @@ from dlt.sources.sql_database.schema_types import (
 )
 from sqlalchemy import Column
 from sqlalchemy import types as sa
-from sqlalchemy.dialects import mysql
 
 from ingestr.src.adjust import REQUIRED_CUSTOM_DIMENSIONS, adjust_source
 from ingestr.src.adjust.adjust_helpers import parse_filters
@@ -53,6 +53,8 @@ from ingestr.src.dynamodb import dynamodb
 from ingestr.src.facebook_ads import facebook_ads_source, facebook_insights_source
 from ingestr.src.filesystem import readers
 from ingestr.src.filters import table_adapter_exclude_columns
+from ingestr.src.github import github_reactions, github_repo_events, github_stargazers
+from ingestr.src.google_analytics import google_analytics
 from ingestr.src.google_sheets import google_spreadsheet
 from ingestr.src.gorgias import gorgias_source
 from ingestr.src.hubspot import hubspot
@@ -63,6 +65,12 @@ from ingestr.src.mongodb import mongodb_collection
 from ingestr.src.notion import notion_databases
 from ingestr.src.shopify import shopify_source
 from ingestr.src.slack import slack_source
+from ingestr.src.sql_database.callbacks import (
+    chained_query_adapter_callback,
+    custom_query_variable_subsitution,
+    limit_callback,
+    type_adapter_callback,
+)
 from ingestr.src.stripe_analytics import stripe_source
 from ingestr.src.table_definition import TableDefinition, table_string_to_dataclass
 from ingestr.src.tiktok_ads import tiktok_source
@@ -95,27 +103,22 @@ class SqlSource:
         if kwargs.get("incremental_key"):
             start_value = kwargs.get("interval_start")
             end_value = kwargs.get("interval_end")
-
             incremental = dlt.sources.incremental(
                 kwargs.get("incremental_key", ""),
-                # primary_key=(),
                 initial_value=start_value,
                 end_value=end_value,
+                range_end="closed",
+                range_start="closed",
             )
 
         if uri.startswith("mysql://"):
             uri = uri.replace("mysql://", "mysql+pymysql://")
 
-        reflection_level = kwargs.get("sql_reflection_level")
-
-        query_adapter_callback = None
+        query_adapters = []
         if kwargs.get("sql_limit"):
-
-            def query_adapter_callback(query, table):
-                query = query.limit(kwargs.get("sql_limit"))
-                if kwargs.get("incremental_key"):
-                    query = query.order_by(kwargs.get("incremental_key"))
-                return query
+            query_adapters.append(
+                limit_callback(kwargs.get("sql_limit"), kwargs.get("incremental_key"))
+            )
 
         defer_table_reflect = False
         sql_backend = kwargs.get("sql_backend", "sqlalchemy")
@@ -158,6 +161,7 @@ class SqlSource:
                     switchDict = {
                         int: sa.INTEGER,
                         datetime: sa.TIMESTAMP,
+                        date: sa.DATE,
                         pendulum.Date: sa.DATE,
                         pendulum.DateTime: sa.TIMESTAMP,
                     }
@@ -193,38 +197,10 @@ class SqlSource:
                     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)
+            dlt.sources.sql_database.table_rows = table_rows  # type: ignore
 
-        def type_adapter_callback(sql_type):
-            if isinstance(sql_type, mysql.SET):
-                return sa.JSON
-            return sql_type
+            # override the query adapters, the only one we want is the one here in the case of custom queries
+            query_adapters = [custom_query_variable_subsitution(query_value, kwargs)]
 
         builder_res = self.table_builder(
             credentials=ConnectionStringCredentials(uri),
@@ -233,8 +209,8 @@ class SqlSource:
             incremental=incremental,
             backend=sql_backend,
             chunk_size=kwargs.get("page_size", None),
-            reflection_level=reflection_level,
-            query_adapter_callback=query_adapter_callback,
+            reflection_level=kwargs.get("sql_reflection_level", None),
+            query_adapter_callback=chained_query_adapter_callback(query_adapters),
             type_adapter_callback=type_adapter_callback,
             table_adapter_callback=table_adapter_exclude_columns(
                 kwargs.get("sql_exclude_columns", [])
@@ -1338,3 +1314,103 @@ class DynamoDBSource:
             )
 
         return dynamodb(table, creds, incremental)
+
+
+class GoogleAnalyticsSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        parse_uri = urlparse(uri)
+        source_fields = parse_qs(parse_uri.query)
+        cred_path = source_fields.get("credentials_path")
+
+        if not cred_path:
+            raise ValueError("credentials_path is required to connect Google Analytics")
+        credentials = {}
+
+        with open(cred_path[0], "r") as f:
+            credentials = json.load(f)
+
+        property_id = source_fields.get("property_id")
+        if not property_id:
+            raise ValueError("property_id is required to connect to Google Analytics")
+
+        interval_start = kwargs.get("interval_start")
+        start_date = (
+            interval_start.strftime("%Y-%m-%d") if interval_start else "2015-08-14"
+        )
+
+        fields = table.split(":")
+        if len(fields) != 3:
+            raise ValueError(
+                "Invalid table format. Expected format: custom:<dimensions>:<metrics>"
+            )
+
+        dimensions = fields[1].replace(" ", "").split(",")
+
+        datetime = ""
+        for dimension_datetime in ["date", "dateHourMinute", "dateHour"]:
+            if dimension_datetime in dimensions:
+                datetime = dimension_datetime
+                break
+        else:
+            raise ValueError(
+                "You must provide at least one dimension: [dateHour, dateHourMinute, date]"
+            )
+
+        metrics = fields[2].replace(" ", "").split(",")
+        queries = [
+            {"resource_name": "custom", "dimensions": dimensions, "metrics": metrics}
+        ]
+
+        return google_analytics(
+            property_id=property_id[0],
+            start_date=start_date,
+            datetime=datetime,
+            queries=queries,
+            credentials=credentials,
+        ).with_resources("basic_report")
+
+
+class GitHubSource:
+    def handles_incrementality(self) -> bool:
+        return True
+
+    def dlt_source(self, uri: str, table: str, **kwargs):
+        if kwargs.get("incremental_key"):
+            raise ValueError(
+                "Github takes care of incrementality on its own, you should not provide incremental_key"
+            )
+        # github://?access_token=<access_token>&owner=<owner>&repo=<repo>
+        parsed_uri = urlparse(uri)
+        source_fields = parse_qs(parsed_uri.query)
+
+        owner = source_fields.get("owner", [None])[0]
+        if not owner:
+            raise ValueError(
+                "owner of the repository is required to connect with GitHub"
+            )
+
+        repo = source_fields.get("repo", [None])[0]
+        if not repo:
+            raise ValueError(
+                "repo variable is required to retrieve data for a specific repository from GitHub."
+            )
+
+        access_token = source_fields.get("access_token", [None])[0]
+        if not access_token and table not in ["repo_events"]:
+            raise ValueError("access_token is required to connect with GitHub")
+
+        if table in ["issues", "pull_requests"]:
+            return github_reactions(
+                owner=owner, name=repo, access_token=access_token
+            ).with_resources(table)
+        elif table == "repo_events":
+            return github_repo_events(owner=owner, name=repo, access_token=access_token)
+        elif table == "stargazers":
+            return github_stargazers(owner=owner, name=repo, access_token=access_token)
+        else:
+            raise ValueError(
+                f"Resource '{table}' is not supported for GitHub source yet, if you are interested in it please create a GitHub issue at https://github.com/bruin-data/ingestr"
+            )

ingestr/src/sql_database/callbacks.py

@@ -0,0 +1,66 @@
+from datetime import datetime
+
+from sqlalchemy import text
+from sqlalchemy import types as sa
+from sqlalchemy.dialects import mysql
+
+
+def type_adapter_callback(sql_type):
+    if isinstance(sql_type, mysql.SET):
+        return sa.JSON
+    return sql_type
+
+
+def chained_query_adapter_callback(query_adapters):
+    """
+    This function is used to chain multiple query adapters together,.
+    This gives us the flexibility to introduce various adapters based on the given command parameters.
+    """
+
+    def callback(query, table):
+        for adapter in query_adapters:
+            query = adapter(query, table)
+
+        return query
+
+    return callback
+
+
+def limit_callback(sql_limit: int, incremental_key: str):
+    def callback(query, table):
+        query = query.limit(sql_limit)
+        if incremental_key:
+            query = query.order_by(incremental_key)
+        return query
+
+    return callback
+
+
+def custom_query_variable_subsitution(query_value: str, kwargs: dict):
+    def 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 text(query_value).bindparams(**params)
+
+    return callback

ingestr/src/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ingestr
-Version: 0.12.3
+Version: 0.12.5
 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
@@ -17,10 +17,11 @@ Requires-Python: >=3.9
 Requires-Dist: asana==3.2.3
 Requires-Dist: confluent-kafka>=2.6.1
 Requires-Dist: databricks-sql-connector==2.9.3
-Requires-Dist: dlt==1.4.0
+Requires-Dist: dlt==1.5.0
 Requires-Dist: duckdb-engine==0.13.5
 Requires-Dist: duckdb==1.1.3
 Requires-Dist: facebook-business==20.0.0
+Requires-Dist: google-analytics-data==0.18.16
 Requires-Dist: google-api-python-client==2.130.0
 Requires-Dist: google-cloud-bigquery-storage==2.24.0
 Requires-Dist: mysql-connector-python==9.1.0
@@ -33,7 +34,7 @@ Requires-Dist: pyathena==3.9.0
 Requires-Dist: pymongo==4.10.1
 Requires-Dist: pymysql==1.1.1
 Requires-Dist: pyrate-limiter==3.7.0
-Requires-Dist: redshift-connector==2.1.3
+Requires-Dist: redshift-connector==2.1.5
 Requires-Dist: rich==13.9.4
 Requires-Dist: rudder-sdk-python==2.1.4
 Requires-Dist: s3fs==2024.10.0

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

@@ -1,18 +1,18 @@
-ingestr/main.py,sha256=wkU2uLMy1q8YarJ9mXNfJepeRjp6AuPDeNDOmMUt6n0,22309
+ingestr/main.py,sha256=xLQiPHoD7dNvrHfNTwD379wHg6xZGmLxzPzQLq2E1RA,24746
 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/factory.py,sha256=aE7TjHzONb4DKYcfh_6-CJJfvs4lmw7iUySvSm4yQbM,4516
 ingestr/src/filters.py,sha256=0JQXeAr2APFMnW2sd-6BlAMWv93bXV17j8b5MM8sHmM,580
-ingestr/src/sources.py,sha256=Jy1N5EfbxfTae0L7PiZmPVxVYWLvOuLlw3kJ6vbT50M,48027
+ingestr/src/sources.py,sha256=FXUTmII3DiEANZN37P9-dTFFRzpv0PL8bfaQvr0un8w,50761
 ingestr/src/table_definition.py,sha256=REbAbqdlmUMUuRh8nEQRreWjPVOQ5ZcfqGkScKdCrmk,390
 ingestr/src/time.py,sha256=H_Fk2J4ShXyUM-EMY7MqCLZQhlnZMZvO952bmZPc4yE,254
-ingestr/src/version.py,sha256=Qu8-91hLcRe7wfW37PwNdivTonHHKLrqtJPOAq3Jvhc,23
+ingestr/src/version.py,sha256=QFQfu3CUVe9Ncr8kv3aaBY3oWrZmv8xboen_Uwy7eXU,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
 ingestr/src/appsflyer/_init_.py,sha256=ne2-9FQ654Drtd3GkKQv8Bwb6LEqCnJw49MfO5Jyzgs,739
 ingestr/src/appsflyer/client.py,sha256=TNmwakLzmO6DZW3wcfLfQRl7aNBHgFqSsk4ef-MmJ1w,3084
-ingestr/src/arrow/__init__.py,sha256=AgU7S9Ra3ZeeG00Mf32zxO5sgMFfRnTdOSirUJ1Pu10,2976
+ingestr/src/arrow/__init__.py,sha256=8fEntgHseKjFMiPQIzxYzw_raicNsEgnveLi1IzBca0,2848
 ingestr/src/asana_source/__init__.py,sha256=Y4Ti_876Yong420fQ2o4A97TdgrZNlZVxlTMLyXdSjA,8116
 ingestr/src/asana_source/helpers.py,sha256=PukcdDQWIGqnGxuuobbLw4hUy4-t6gxXg_XywR7Lg9M,375
 ingestr/src/asana_source/settings.py,sha256=-2tpdkwh04RvLKFvwQodnFLYn9MaxOO1hsebGnDQMTU,2829
@@ -27,6 +27,13 @@ ingestr/src/facebook_ads/settings.py,sha256=1IxZeP_4rN3IBvAncNHOoqpzAirx0Hz-MUK_
 ingestr/src/filesystem/__init__.py,sha256=wHHaKFuAjsR_ZRjl6g_Flf6FhVs9qhwREthTr03_7cc,4162
 ingestr/src/filesystem/helpers.py,sha256=bg0muSHZr3hMa8H4jN2-LGWzI-SUoKlQNiWJ74-YYms,3211
 ingestr/src/filesystem/readers.py,sha256=a0fKkaRpnAOGsXI3EBNYZa7x6tlmAOsgRzb883StY30,3987
+ingestr/src/github/__init__.py,sha256=csA2VcjOxXrVrvp7zY-JodO9Lpy98bJ4AqRdHCLTcGM,5838
+ingestr/src/github/helpers.py,sha256=Tmnik9811zBWNO6cJwV9PFQxEx2j32LHAQCvNbubsEI,6759
+ingestr/src/github/queries.py,sha256=W34C02jUEdjFmOE7f7u9xvYyBNDMfVZAu0JIRZI2mkU,2302
+ingestr/src/github/settings.py,sha256=N5ahWrDIQ_4IWV9i-hTXxyYduqY9Ym2BTwqsWxcDdJ8,258
+ingestr/src/google_analytics/__init__.py,sha256=HjA13wfJm2MGfy3h_DiM5ekkNqM2dgwYCKJ3pprnDtI,2482
+ingestr/src/google_analytics/helpers/__init__.py,sha256=y_q7dinlEwNBEpq6kCzjTa8lAhe2bb23bDPP0fcy7fY,2744
+ingestr/src/google_analytics/helpers/data_processing.py,sha256=fIdEKr9CmZN_s1T2i9BL8IYTPPqNoK6Vaquq2y8StfE,6072
 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
@@ -56,6 +63,8 @@ ingestr/src/shopify/settings.py,sha256=StY0EPr7wFJ7KzRRDN4TKxV0_gkIS1wPj2eR4AYSs
 ingestr/src/slack/__init__.py,sha256=UF-ficQ6K32u1EHytW3P35suACo9wuc6nMrAPViyZL8,9981
 ingestr/src/slack/helpers.py,sha256=08TLK7vhFvH_uekdLVOLF3bTDe1zgH0QxHObXHzk1a8,6545
 ingestr/src/slack/settings.py,sha256=NhKn4y1zokEa5EmIZ05wtj_-I0GOASXZ5V81M1zXCtY,457
+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=VEXH4to2vNojN4rk3qsypR7urtTzaxSBB3IBiD5tuoE,4514
 ingestr/src/stripe_analytics/helpers.py,sha256=iqZOyiGIOhOAhVXXU16DP0hkkTKcTrDu69vAJoTxgEo,1976
 ingestr/src/stripe_analytics/settings.py,sha256=rl9L5XumxO0pjkZf7MGesXHp4QLRgnz3RWLuDWDBKXo,380
@@ -77,8 +86,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.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,,
+ingestr-0.12.5.dist-info/METADATA,sha256=QhFy0K3FUgK2VGdShWUOeTj_HbHElVPD64bAf2k-4G0,7956
+ingestr-0.12.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+ingestr-0.12.5.dist-info/entry_points.txt,sha256=oPJy0KBnPWYjDtP1k8qwAihcTLHSZokSQvRAw_wtfJM,46
+ingestr-0.12.5.dist-info/licenses/LICENSE.md,sha256=cW8wIhn8HFE-KLStDF9jHQ1O_ARWP3kTpk_-eOccL24,1075
+ingestr-0.12.5.dist-info/RECORD,,