ingestr 0.13.35__tar.gz → 0.13.36__tar.gz

ingestr-0.13.36/.gitleaksignore

@@ -0,0 +1,4 @@
+ingestr/src/telemetry/event.py:generic-api-key:17
+ingestr/src/testdata/fakebqcredentials.json:private-key:5
+docs/supported-sources/shopify.md:generic-api-key:26
+ingestr/src/google_analytics/helpers_test.py:generic-api-key:36

{ingestr-0.13.35 → ingestr-0.13.36}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ingestr
-Version: 0.13.35
+Version: 0.13.36
 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.35 → ingestr-0.13.36}/docs/supported-sources/frankfurter.md

@@ -41,7 +41,9 @@ ingestr ingest \
 ### **`--interval-end` (Optional)**
 - **Description**: The end date for fetching historical exchange rates.
 - **Value**: A date in the format `YYYY-MM-DD` (e.g., `'2025-03-28'`).
-- **Purpose**: Defines the ending point for fetching historical data. If not provided, it defaults to the value of `--interval-start`.
+- **Purpose**: Defines the end point for fetching historical data. 
+    - If `--interval-start` is provided without `--interval-end`, `--interval-end` defaults to the current date and retrieves up until the latest published data.
+    - If `--interval-end` is provided without `--interval-start`, it will be ignored and the call will retrieve the last published data.
     - For `latest` and `currencies` this parameter is ignored.
 
 ---
@@ -104,7 +106,7 @@ ingestr ingest \
 - **Primary Key**: Composite key of `date` and `currency_name`.
 - **Notes**:
   - An optional start and end date can be added via the arguments `--interval-start` and optionally `--interval-end` to define the date range (see examples below). If no start date is specified, the date will default today's date (and thus return the latest exchange rates).
-  - If a start date but no end date is specified, then the end date will default to the start date and ingestr will retrieve data for the specified start date only.
+  - If a start date but no end date is specified, then the end date will default to today's date and ingestr will retrieve data up until the latest published data.
   - Note that the [Frankfurter API](https://www.frankfurter.dev/) only publishes updates Monday-Friday. If the given date is on the weekend, the date will default to the previous Friday. The source is however implemented in ingestr in such a way as to avoid duplicating rows of data in this case (see [Incremental Loading - Replace](https://bruin-data.github.io/ingestr/getting-started/incremental-loading.html)).
 
 #### **Example Table: Handling Weekend Dates**

ingestr-0.13.36/docs/supported-sources/freshdesk.md

@@ -0,0 +1,47 @@
+# Freshdesk
+
+[Freshdesk](https://www.freshworks.com/freshdesk/) is a cloud-based customer service platform that helps businesses manages customer support via multiple channels including email,phone,websites, and social media.
+
+ingestr supports Freshdesk as a source.
+
+## URI format
+
+The URI format for Freshdesk is:
+
+```
+freshdesk://<domain>?api_key=<api_key>
+```
+
+URI parameters:
+- `api_key` :  The API token used for authentication with Freshdesk.
+- `domain`: The domain of your Freshdesk account, found in your account URL. For example, if your account URL is https://my_company.freshdesk.com/, then `my_company` is your domain.
+
+The URI is used to connect to the Freshdesk API for extracting data.
+
+## Setting up a Freshdesk integration
+
+Freshdesk requires a few steps to set up an integration, please follow dltHub [setup guide](https://dlthub.com/docs/dlt-ecosystem/verified-sources/freshdesk#setup-guide).
+
+After completing the guide,, you will have your  `api_key` and `domain`. For example, if your api_key is
+`test_key` and domain `my_company`, you can use the following command to copy data from Freshdesk into a DuckDB database:
+
+```sh
+ingestr ingest --source-uri 'freshdesk://$DOMAIN?api_key=$API_KEY' --source-table 'contacts' --dest-uri duckdb:///freshdesk.duckdb --dest-table 'dest.contacts'
+```
+This command copies data from the Freshdesk source to DuckDB.
+
+<img alt="freshdesk_img" src="../media/freshdesk_ingestion.png" />
+
+## Available Tables
+The Freshdesk source allows you to ingest the following tables:
+
+| S.No. | Name      | Description                                                                               |
+| ----- | --------- | ----------------------------------------------------------------------------------------- |
+| 1.    | agents    |  Users responsible for managing and resolving customer inquiries and support tickets.     |
+| 2.    | companies |  Customer organizations or groups that agents support.                                    |
+| 3.    | contacts  |  Individuals or customers who reach out for support.                                      |
+| 4.    | groups    |  Agents organized based on specific criteria.                                             |
+| 5.    | roles     |  Predefined sets of permissions that determine what actions an agent can perform.         |
+| 6.    | tickets   |  Customer inquiries or issues submitted via various channels like email, chat, phone, etc. |
+
+Use these as the `--source-table` parameter in the `ingestr ingest` command.

{ingestr-0.13.35 → ingestr-0.13.36}/docs/supported-sources/google_analytics.md

@@ -19,31 +19,64 @@ URI parameters:
 - `credentials_path`: The path to the service account JSON file.
 - `property_id`: It is a unique number that identifies a particular property on Google Analytics. [Follow this guide](https://developers.google.com/analytics/devguides/reporting/data/v1/property-id#what_is_my_property_id) to know more about property ID.
 
-## Setting up an Google Analytics Integration
+## Setting up a Google Analytics Integration
 Google Analytics requires a few steps to set up an integration, please follow the guide dltHub [has built here](https://dlthub.com/docs/dlt-ecosystem/verified-sources/google_analytics#grab-google-service-account-credentials). Once you complete the guide, you should have an `.json` file  and `project_id`. 
 
-## Table: Custom Reports
-Custom reports allow you to retrieve data based on specific `dimensions` and  `metrics`.
+## Available Tables:
+### Custom reports 
+- `Custom reports`: allow you to retrieve data based on specific `dimensions` and  `metrics`.
 
-Custom Table Format:
+ #### Custom Table Format:
 ```
 custom:<dimensions>:<metrics>
 ```
 
-### Parameters:
-- `dimensions`(required): A comma-separated list of [dimensions](https://developers.google.com/analytics/devguides/reporting/data/v1/exploration-api-schema#dimensions) to retrieve.
-- `metrics`(required): A comma-separated list of [metrics](https://developers.google.com/analytics/devguides/reporting/data/v1/exploration-api-schema#metrics) to retrieve.
+ #### Parameters:
+- `dimensions`(required): A comma-separated list of [dimensions](https://developers.google.com/analytics/devguides/reporting/data/v1/api-schema#dimensions) to retrieve.
+- `metrics`(required): A comma-separated list of [metrics](https://developers.google.com/analytics/devguides/reporting/data/v1/api-schema#metrics) to retrieve.
 
-### Example
+ #### Example
 
 ```sh
 ingestr ingest \
     --source-uri "googleanalytics://?credentials_path="ingestr/src/g_analytics.json&property_id=id123" \
-    --source-table "custom:city,date:clicks,activeUsers,newUsers" \
+    --source-table "custom:date:activeUsers" \
     --dest-uri "duckdb:///analytics.duckdb" \
     --dest-table "dest.custom"
 ```
 
 This command will retrieve report and save it to the `dest.custom` table in the DuckDB database.
 
-<img alt="google_analytics_img" src="../media/googleanalytics.png" />
+<img alt="google_analytics_img" src="../media/googleanalytics.png" />
+
+
+### Realtime reports
+`Realtime reports`: allows you to retrieve data based on specific `dimensions`, `metrics`, with optional `minutes_ranges`.
+
+ #### Realtime Report Table Format:
+```
+realtime:<dimensions>:<metrics>
+
+```
+```
+realtime:<dimensions>:<metrics>:<minutes_ranges>
+```
+
+ #### Parameters:
+- `dimensions`(required): A comma-separated list of [dimensions](https://developers.google.com/analytics/devguides/reporting/data/v1/exploration-api-schema#dimensions) to retrieve.
+- `metrics`(required): A comma-separated list of [metrics](https://developers.google.com/analytics/devguides/reporting/data/v1/exploration-api-schema#metrics) to retrieve.
+- `minutes_ranges`(optional): Allows you to specify time windows for retrieving data. You can define up to two time ranges in your query, formatted as comma-separated values (e.g., "0-5,25-29"). Each range represents minutes in the past from the current time.
+If no minute_ranges are specified, the system defaults to retrieving data from the last 30 minutes. For more information read [here](https://developers.google.com/analytics/devguides/reporting/data/v1/realtime-basics#minute_ranges)
+
+#### Example
+
+```sh
+ingestr ingest \
+    --source-uri "googleanalytics://?credentials_path="ingestr/src/g_analytics.json&property_id=id123" \
+    --source-table "realtime:streamId:activeUsers:0-4,10-29" \
+    --dest-uri "duckdb:///analytics.duckdb" \
+    --dest-table "dest.realtime"
+```
+This command will retrieve report and save it to the `dest.realtime` table in the DuckDB database.
+
+<img alt="google_analytics_realtime_report_img" src="../media/google_analytics_realtime_report.png"/>

ingestr-0.13.36/ingestr/src/buildinfo.py

@@ -0,0 +1 @@
+version = "v0.13.36"

{ingestr-0.13.35 → ingestr-0.13.36}/ingestr/src/factory.py

@@ -53,6 +53,7 @@ from ingestr.src.sources import (
     StripeAnalyticsSource,
     TikTokSource,
     ZendeskSource,
+    FreshdeskSource,
 )
 
 SQL_SOURCE_SCHEMES = [
@@ -148,6 +149,7 @@ class SourceDestinationFactory:
         "kinesis": KinesisSource,
         "pipedrive": PipedriveSource,
         "frankfurter": FrankfurterSource,
+        "freshdesk": FreshdeskSource,
     }
     destinations: Dict[str, Type[DestinationProtocol]] = {
         "bigquery": BigQueryDestination,

{ingestr-0.13.35 → ingestr-0.13.36}/ingestr/src/frankfurter/__init__.py

@@ -1,4 +1,4 @@
-from typing import Any, Iterator, Optional
+from typing import Any, Iterator
 
 import dlt
 from dlt.common.pendulum import pendulum
@@ -13,25 +13,28 @@ from ingestr.src.frankfurter.helpers import get_path_with_retry
     max_table_nesting=0,
 )
 def frankfurter_source(
-    table: str,
-    start_date: Optional[TAnyDateTime] = None,
-    end_date: Optional[TAnyDateTime] = None,
+    start_date: TAnyDateTime,
+    end_date: TAnyDateTime,
 ) -> Any:
     """
     A dlt source for the frankfurter.dev API. It groups several resources (in this case frankfurter.dev API endpoints) containing
     various types of data: currencies, latest rates, historical rates.
-
-    Returns the appropriate resource based on the provided parameters.
     """
-    # Determine which resource to return based on the `table` parameter
-    if table == "currencies":
-        return currencies()
+    date_time = dlt.sources.incremental(
+
+        "date",
+        initial_value=start_date,
+        end_value=end_date,
+        range_start="closed",
+        range_end="closed",
+    )
 
-    elif table == "latest":
-        return latest()
+    return (
+        currencies(),
+        latest(),
+        exchange_rates(start_date=date_time, end_date=end_date),
 
-    elif table == "exchange_rates":
-        return exchange_rates(start_date=start_date, end_date=end_date)
+    )
 
 
 @dlt.resource(
@@ -53,13 +56,13 @@ def currencies() -> Iterator[dict]:
 
 
 @dlt.resource(
-    write_disposition="replace",
+    write_disposition="merge",
     columns={
         "date": {"data_type": "text"},
-        "currency_name": {"data_type": "text"},
+        "currency_code": {"data_type": "text"},
         "rate": {"data_type": "double"},
     },
-    primary_key=["date", "currency_name"],  # Composite primary key
+    primary_key=["date", "currency_code"],  # Composite primary key
 )
 def latest() -> Iterator[dict]:
     """
@@ -69,50 +72,54 @@ def latest() -> Iterator[dict]:
     url = "latest?"
 
     # Fetch data
-    latest_data = get_path_with_retry(url)
+    data = get_path_with_retry(url)
 
     # Extract rates and base currency
-    rates = latest_data["rates"]
+    rates = data["rates"]
 
-    # Prepare the date
-    date = pendulum.now().to_date_string()
+    date = pendulum.parse(data["date"])
 
     # Add the base currency (EUR) with a rate of 1.0
     yield {
         "date": date,
-        "currency_name": "EUR",
+        "currency_code": "EUR",
         "rate": 1.0,
     }
 
     # Add all currencies and their rates
-    for currency_name, rate in rates.items():
+    for currency_code, rate in rates.items():
         yield {
             "date": date,
-            "currency_name": currency_name,
+            "currency_code": currency_code,
             "rate": rate,
         }
 
 
 @dlt.resource(
-    write_disposition="replace",
+    write_disposition="merge",
     columns={
         "date": {"data_type": "text"},
-        "currency_name": {"data_type": "text"},
+        "currency_code": {"data_type": "text"},
         "rate": {"data_type": "double"},
     },
-    primary_key=["date", "currency_name"],  # Composite primary key
+    primary_key=("date", "currency_code"),  # Composite primary key
 )
 def exchange_rates(
-    start_date: TAnyDateTime,
     end_date: TAnyDateTime,
+    start_date: dlt.sources.incremental[TAnyDateTime] = dlt.sources.incremental("date"),
 ) -> Iterator[dict]:
     """
     Fetches exchange rates for a specified date range.
-    If only start_date is provided, fetches data for that date.
+    If only start_date is provided, fetches data until now.
     If both start_date and end_date are provided, fetches data for each day in the range.
     """
-    start_date_str = ensure_pendulum_datetime(start_date).format("YYYY-MM-DD")
-    end_date_str = ensure_pendulum_datetime(end_date).format("YYYY-MM-DD")
+    # Ensure start_date.last_value is a pendulum.DateTime object
+    start_date_obj = ensure_pendulum_datetime(start_date.last_value)  # type: ignore
+    start_date_str = start_date_obj.format("YYYY-MM-DD")
+
+    # Ensure end_date is a pendulum.DateTime object
+    end_date_obj = ensure_pendulum_datetime(end_date)
+    end_date_str = end_date_obj.format("YYYY-MM-DD")
 
     # Compose the URL
     url = f"{start_date_str}..{end_date_str}?"
@@ -121,22 +128,23 @@ def exchange_rates(
     data = get_path_with_retry(url)
 
     # Extract base currency and rates from the API response
-    base_currency = data["base"]
     rates = data["rates"]
 
     # Iterate over the rates dictionary (one entry per date)
     for date, daily_rates in rates.items():
+        formatted_date = pendulum.parse(date)
+
         # Add the base currency with a rate of 1.0
         yield {
-            "date": date,
-            "currency_name": base_currency,
+            "date": formatted_date,
+            "currency_code": "EUR",
             "rate": 1.0,
         }
 
         # Add all other currencies and their rates
-        for currency_name, rate in daily_rates.items():
+        for currency_code, rate in daily_rates.items():
             yield {
-                "date": date,
-                "currency_name": currency_name,
+                "date": formatted_date,
+                "currency_code": currency_code,
                 "rate": rate,
             }

{ingestr-0.13.35 → ingestr-0.13.36}/ingestr/src/frankfurter/helpers.py

@@ -8,7 +8,7 @@ FRANKFURTER_API_URL = "https://api.frankfurter.dev/v1/"
 
 
 def get_url_with_retry(url: str) -> StrAny:
-    r = requests.get(url)
+    r = requests.get(url, timeout=5)
     return r.json()  # type: ignore
 
 
@@ -19,7 +19,7 @@ def get_path_with_retry(path: str) -> StrAny:
 def validate_dates(start_date: datetime, end_date: datetime) -> None:
     current_date = pendulum.now()
 
-    # Check if start_date is in the future
+    # Check if start_date is in the futurep
     if start_date > current_date:
         raise ValueError("Interval-start cannot be in the future.")
 

ingestr-0.13.36/ingestr/src/freshdesk/__init__.py

@@ -0,0 +1,72 @@
+"""This source uses Freshdesk API and dlt to load data such as Agents, Companies, Tickets
+etc. to the database"""
+
+from typing import Any, Dict, Generator, Iterable, List, Optional
+
+import dlt
+from dlt.sources import DltResource
+
+from .freshdesk_client import FreshdeskClient
+from .settings import DEFAULT_ENDPOINTS
+
+
+@dlt.source()
+def freshdesk_source(
+    endpoints: Optional[List[str]] = None,
+    per_page: int = 100,
+    domain: str = dlt.secrets.value,
+    api_secret_key: str = dlt.secrets.value,
+) -> Iterable[DltResource]:
+    """
+    Retrieves data from specified Freshdesk API endpoints.
+
+    This source supports pagination and incremental data loading. It fetches data from a list of
+    specified endpoints, or defaults to predefined endpoints in 'settings.py'.
+
+    Args:
+        endpoints: A list of Freshdesk API endpoints to fetch. Deafults to 'settings.py'.
+        per_page: The number of items to fetch per page, with a maximum of 100.
+        domain: The Freshdesk domain from which to fetch the data. Defaults to 'config.toml'.
+        api_secret_key: Freshdesk API key. Defaults to 'secrets.toml'.
+
+    Yields:
+        Iterable[DltResource]: Resources with data updated after the last 'updated_at'
+        timestamp for each endpoint.
+    """
+    # Instantiate FreshdeskClient with the provided domain and API key
+    freshdesk = FreshdeskClient(api_key=api_secret_key, domain=domain)
+
+    def incremental_resource(
+        endpoint: str,
+        updated_at: Optional[Any] = dlt.sources.incremental(
+            "updated_at", initial_value="2022-01-01T00:00:00Z"
+        ),
+    ) -> Generator[Dict[Any, Any], Any, None]:
+        """
+        Fetches and yields paginated data from a specified API endpoint.
+        Each page of data is fetched based on the `updated_at` timestamp
+        to ensure incremental loading.
+        """
+
+        # Retrieve the last updated timestamp to fetch only new or updated records.
+        if updated_at is not None:
+            updated_at = updated_at.last_value
+
+        # Use the FreshdeskClient instance to fetch paginated responses
+        yield from freshdesk.paginated_response(
+            endpoint=endpoint,
+            per_page=per_page,
+            updated_at=updated_at,
+        )
+
+    # Set default endpoints if not provided
+    endpoints = endpoints or DEFAULT_ENDPOINTS
+
+    # For each endpoint, create and yield a DLT resource
+    for endpoint in endpoints:
+        yield dlt.resource(
+            incremental_resource,
+            name=endpoint,
+            write_disposition="merge",
+            primary_key="id",
+        )(endpoint=endpoint)

ingestr-0.13.36/ingestr/src/freshdesk/freshdesk_client.py

@@ -0,0 +1,102 @@
+"""Freshdesk Client for making authenticated requests"""
+
+import logging
+import time
+from typing import Any, Dict, Iterable, Optional
+
+from dlt.common.typing import TDataItem
+from dlt.sources.helpers import requests
+
+
+class FreshdeskClient:
+    """
+    Client for making authenticated requests to the Freshdesk API. It incorporates API requests with
+    rate limit and pagination.
+
+    Attributes:
+        api_key (str): The API key used for authenticating requests to the Freshdesk API.
+        domain (str): The Freshdesk domain specific to the user, used in constructing the base URL.
+        base_url (str): The base URL constructed from the domain, targeting the Freshdesk API v2.
+    """
+
+    def __init__(self, api_key: str, domain: str):
+        # Initialize the FreshdeskClient instance with API key and domain.
+        # The API key is used for authentication with the Freshdesk API.
+        # The domain specifies the unique Freshdesk domain of the user.
+
+        # Store the API key provided during initialization.
+        self.api_key = api_key
+        # Store the Freshdesk domain provided during initialization.
+        self.domain = domain
+
+        # Construct the base URL for the API requests.
+        # This URL is formed by appending the domain to the standard Freshdesk API base URL format.
+        # All API requests will use this base URL as their starting point.
+        self.base_url = f"https://{domain}.freshdesk.com/api/v2"
+
+    def _request_with_rate_limit(self, url: str, **kwargs: Any) -> requests.Response:
+        """
+        Handles rate limits in HTTP requests and ensures
+        that the client doesn't exceed the limit set by the server.
+        """
+
+        while True:
+            try:
+                response = requests.get(url, **kwargs, auth=(self.api_key, "X"))
+                response.raise_for_status()
+
+                return response
+            except requests.HTTPError as e:
+                if e.response.status_code == 429:
+                    # Get the 'Retry-After' header to know how long to wait
+                    # Fallback to 60 seconds if header is missing
+                    seconds_to_wait = int(e.response.headers.get("Retry-After", 60))
+                    # Log a warning message
+                    logging.warning(
+                        "Rate limited. Waiting to retry after: %s secs", seconds_to_wait
+                    )
+
+                    # Wait for the specified number of seconds before retrying
+                    time.sleep(seconds_to_wait)
+                else:
+                    # If the error is not a rate limit (429), raise the exception to be
+                    # handled elsewhere or stop execution
+                    raise
+
+    def paginated_response(
+        self,
+        endpoint: str,
+        per_page: int,
+        updated_at: Optional[str] = None,
+    ) -> Iterable[TDataItem]:
+        """
+        Fetches a paginated response from a specified endpoint.
+
+        This method will continuously fetch data from the given endpoint,
+        page by page, until no more data is available or until it reaches data
+        updated at the specified timestamp.
+        """
+        page = 1
+        while True:
+            # Construct the URL for the specific endpoint
+            url = f"{self.base_url}/{endpoint}"
+
+            params: Dict[str, Any] = {"per_page": per_page, "page": page}
+
+            # Implement date range splitting logic here, if applicable
+            if endpoint in ["tickets", "contacts"]:
+                param_key = (
+                    "updated_since" if endpoint == "tickets" else "_updated_since"
+                )
+                if updated_at:
+                    params[param_key] = updated_at
+
+            # Handle requests with rate-limiting
+            # A maximum of 300 pages (30000 tickets) will be returned.
+            response = self._request_with_rate_limit(url, params=params)
+            data = response.json()
+
+            if not data:
+                break  # Stop if no data or max page limit reached
+            yield data
+            page += 1

ingestr-0.13.36/ingestr/src/freshdesk/settings.py

@@ -0,0 +1,9 @@
+"""
+This module defines default settings for the Freshdesk integration.
+
+It specifies a list of default endpoints to be used when interacting with the Freshdesk API,
+covering common entities such as agents, companies, contacts, groups, roles, and tickets.
+"""
+
+# Define default endpoints for the Freshdesk API integration.
+DEFAULT_ENDPOINTS = ["agents", "companies", "contacts", "groups", "roles", "tickets"]

{ingestr-0.13.35 → ingestr-0.13.36}/ingestr/src/google_analytics/__init__.py

@@ -13,9 +13,10 @@ from google.analytics.data_v1beta import BetaAnalyticsDataClient
 from google.analytics.data_v1beta.types import (
     Dimension,
     Metric,
+    MinuteRange,
 )
 
-from .helpers import get_report
+from .helpers import get_realtime_report, get_report
 
 
 @dlt.source(max_table_nesting=0)
@@ -29,6 +30,7 @@ def google_analytics(
     start_date: Optional[pendulum.DateTime] = pendulum.datetime(2024, 1, 1),
     end_date: Optional[pendulum.DateTime] = None,
     rows_per_page: int = 10000,
+    minute_range_objects: List[MinuteRange] | None = None,
 ) -> List[DltResource]:
     try:
         property_id = int(property_id)
@@ -58,7 +60,7 @@ def google_analytics(
     dimensions = query["dimensions"]
 
     @dlt.resource(
-        name="basic_report",
+        name="custom",
         merge_key=datetime_dimension,
         write_disposition="merge",
     )
@@ -87,6 +89,22 @@ def google_analytics(
             end_date=end_date,
         )
 
+    # real time report
+    @dlt.resource(
+        name="realtime",
+        merge_key="ingested_at",
+        write_disposition="merge",
+    )
+    def real_time_report() -> Iterator[TDataItem]:
+        yield from get_realtime_report(
+            client=client,
+            property_id=property_id,
+            dimension_list=[Dimension(name=dimension) for dimension in dimensions],
+            metric_list=[Metric(name=metric) for metric in query["metrics"]],
+            per_page=rows_per_page,
+            minute_range_objects=minute_range_objects,
+        )
+
     # res = dlt.resource(
     #     basic_report, name="basic_report", merge_key=datetime_dimension, write_disposition="merge"
     # )(
@@ -103,4 +121,4 @@ def google_analytics(
     #     ),
     # )
 
-    return [basic_report]
+    return [basic_report, real_time_report]