ingestr 0.13.47__tar.gz → 0.13.49__tar.gz

{ingestr-0.13.47 → ingestr-0.13.49}/.gitleaksignore

@@ -1,4 +1,5 @@
 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
+docs/supported-sources/smartsheets.md:generic-api-key:38
 ingestr/src/google_analytics/helpers_test.py:generic-api-key:36

{ingestr-0.13.47 → ingestr-0.13.49}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ingestr
-Version: 0.13.47
+Version: 0.13.49
 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
@@ -163,6 +163,7 @@ Requires-Dist: shellingham==1.5.4
 Requires-Dist: simple-salesforce==1.12.6
 Requires-Dist: simplejson==3.20.1
 Requires-Dist: six==1.17.0
+Requires-Dist: smartsheet-python-sdk==3.0.5
 Requires-Dist: smmap==5.0.2
 Requires-Dist: snowflake-connector-python==3.14.0
 Requires-Dist: snowflake-sqlalchemy==1.6.1
@@ -467,6 +468,11 @@ Pull requests are welcome. However, please open an issue first to discuss what y
         <td>✅</td>
         <td>-</td>
     </tr>
+    <tr>
+        <td>Smartsheet</td>
+        <td>✅</td>
+        <td>-</td>
+    </tr>
     <tr>
         <td>Stripe</td>
         <td>✅</td>

{ingestr-0.13.47 → ingestr-0.13.49}/README.md

@@ -263,6 +263,11 @@ Pull requests are welcome. However, please open an issue first to discuss what y
         <td>✅</td>
         <td>-</td>
     </tr>
+    <tr>
+        <td>Smartsheet</td>
+        <td>✅</td>
+        <td>-</td>
+    </tr>
     <tr>
         <td>Stripe</td>
         <td>✅</td>

{ingestr-0.13.47 → ingestr-0.13.49}/docs/.vitepress/config.mjs

@@ -139,7 +139,9 @@ export default defineConfig({
               { text: "Salesforce", link: "/supported-sources/salesforce.md" },
               { text: "Shopify", link: "/supported-sources/shopify.md" },
               { text: "Slack", link: "/supported-sources/slack.md" },
+              { text: "Smartsheet", link: "/supported-sources/smartsheets.md" },
               { text: "Spanner", link: "/supported-sources/spanner.md" },
+              { text: "Solidgate", link: "/supported-sources/solidgate.md" },
               { text: "Stripe", link: "/supported-sources/stripe.md" },
               { text: "TikTok Ads", link: "/supported-sources/tiktok-ads.md" },
               { text: "Zendesk", link: "/supported-sources/zendesk.md" },

ingestr-0.13.49/docs/supported-sources/frankfurter.md

@@ -0,0 +1,48 @@
+# Frankfurter
+
+[Frankfurter API](https://www.frankfurter.dev/) is an online platform which fetches current and historical exchnge rate data.
+
+ingestr supports Frankfurter as a source primarily to demonstrate ingestr's features since the API doesn't require any authentication. 
+
+## URI format
+
+The URI format for Frankfurter is as follows:
+
+```plaintext
+frankfurter://?base=<currency-code-here>
+```
+
+URI parameters:
+- `base`: defines the base currency code (e.g. EUR, USD, IDR) used to calculate the exchange rates. 
+
+
+## Set-Up Frankfurter Integration
+
+Let's say you want to fetch the exchange rates for a certain period with the base currency as Indian Rupees. Here's a sample command that will copy this data into your DuckDB database:
+
+```bash
+ingestr ingest \
+--source-uri 'frankfurter://?base=INR' \
+--interval-start '2025-03-20' \ 
+--interval-end '2025-03-28' \       
+--source-table 'exchange_rates' \    
+--dest-uri 'duckdb///frankfurter.duckdb' \
+--dest-table 'my_schema.exchange_rates'
+```
+
+The result of this command will be a list of currency exchange rates from 20.03.2025-28.03.2025 with INR as the base currency in your DuckDB database. 
+
+## Tables
+
+- `latest`: Fetches the latest exchange rates.
+- `exchange_rates`: Fetches historical exchange rates for a specified date range.
+- `currencies`: Fetches a list of the available currencies and their ISO 4217 currency code (e.g. `USD`, `EUR`, `GBP`).
+
+Use these as `--source-table` parameter in the `ingestr ingest` command.
+
+
+**Notes**:
+- The arguments `--interval-start` and `--interval-end` are only relevant for the table exchange_rates.
+- 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.
+

ingestr-0.13.49/docs/supported-sources/s3.md

@@ -0,0 +1,136 @@
+# Amazon S3
+
+Amazon Simple Storage Service (S3) is a scalable cloud storage service offered by Amazon Web Services (AWS). It allows users to store and retrieve extensive amounts of data from anywhere on the web.
+
+`ingestr` supports Amazon S3 as both a data source and destination.
+
+## URI Format
+
+The URI for connecting to Amazon S3 is structured as follows:
+
+```plaintext
+s3://?access_key_id=<your_access_key_id>&secret_access_key=<your_secret_access_key>
+```
+
+**URI Parameters:**
+
+*   `access_key_id`: Your AWS access key ID.
+*   `secret_access_key`: Your AWS secret access key.
+*   `endpoint_url`: URL of an S3-Compatiable API Server (optional, destination only)
+*   `layout`: Layout template (optional, destination only)
+
+These credentials are required to authenticate and authorize access to your S3 buckets.
+
+The `--source-table` parameter specifies the S3 bucket and file pattern using the following format:
+
+```
+<bucket-name>/<file-glob-pattern>
+```
+
+## Setting up an S3 Integration
+
+To integrate `ingestr` with Amazon S3, you need an `access_key_id` and a `secret_access_key`. For guidance on obtaining these credentials, refer to the dltHub documentation on [AWS credentials](https://dlthub.com/docs/dlt-ecosystem/verified-sources/filesystem/basic#get-credentials).
+
+Once you have your credentials, you can configure the S3 URI. The `bucket_name` and `path_to_files` (file glob pattern) are specified in the `--source-table` argument.
+
+### Example: Loading data from S3
+
+Let's assume the following details:
+*   `access_key_id`: `AKC3YOW7E`
+*   `secret_access_key`: `XCtkpL5B`
+*   S3 bucket name: `my_bucket`
+*   Path to files within the bucket: `students/students_details.csv`
+
+The following command demonstrates how to copy data from the specified S3 location to a DuckDB database:
+
+```sh
+ingestr ingest \
+    --source-uri 's3://?access_key_id=AKC3YOW7E&secret_access_key=XCtkpL5B' \
+    --source-table 'my_bucket/students/students_details.csv' \
+    --dest-uri duckdb:///s3_data.duckdb \
+    --dest-table 'processed_students.student_details'
+```
+
+This command will create a table named `student_details` within the `processed_students` schema (or equivalent grouping) in the DuckDB database file located at `s3_data.duckdb`.
+
+### Example: Uploading data to S3
+For this, example we'll assume that:
+* `records.db` is a duckdb database.
+* has a table called `public.users`.
+* the S3 credentials are the same as the example above.
+
+The following command demonstrates how to copy data from a local duckdb database to S3:
+```sh
+ingestr ingest \
+    --source-uri 'duckdb:///records.db' \
+    --source-table 'public.users' \
+    --dest-uri 's3://?access_key_id=AKC3YOW7E&secret_access_key=XCtkpL5B' \
+    --dest-table 'my_bucket/records'
+```
+
+This will result in a file structure like the following:
+```
+my_bucket/
+└── records
+    ├── _dlt_loads
+    ├── _dlt_pipeline_state
+    ├── _dlt_version
+    └── users
+        └── <load_id>.<file_id>.parquet
+```
+
+The value of `load_id` and `file_id` is determined at runtime. The default layout creates a folder with the same table name as the source and places the data inside a parquet file. This layout is configurable using the `layout` parameter.
+
+For example, if you would like to create a parquet file with the same name as the source table (as opposed to a folder) you can set `layout` to `{table_name}.{ext}` in the commandline above:
+
+```sh
+ingestr ingest \
+    --source-uri 'duckdb:///records.db' \
+    --source-table 'public.users' \
+    --dest-uri 's3://?layout={table_name}.{ext}&access_key_id=AKC3YOW7E&secret_access_key=XCtkpL5B' \ 
+    --dest-table 'my_bucket/records'
+```
+
+Result:
+```
+my_bucket/
+└── records
+    ├── _dlt_loads
+    ├── _dlt_pipeline_state
+    ├── _dlt_version
+    └── users.parquet
+```
+
+List of available Layout variables is available [here](https://dlthub.com/docs/dlt-ecosystem/destinations/filesystem#available-layout-placeholders)
+
+### Working with S3-Compatiable object stores
+`ingestr` support S3 compatiable storage services like [Minio](https://min.io/), Digital Ocean [spaces](https://www.digitalocean.com/products/spaces) and Cloudflare [R2](https://developers.cloudflare.com/r2/). You can set the `endpoint_url` in your destination URI to write data to these object stores.
+
+For example, if you're running minio on `localhost:9000`, you can write the same data as the [example above](#example-uploading-data-to-s3) by running:
+```sh
+ingestr ingest \
+    --source-uri 'duckdb:///records.db' \
+    --source-table 'public.users' \
+    --dest-uri 's3://?endpoint_url=http://localhost:9000&access_key_id=AKC3YOW7E&secret_access_key=XCtkpL5B' \
+    --dest-table 'my_bucket/records'
+```
+
+::: info NOTE
+S3-Compatiable object stores are currently only supported as destinations. 
+:::
+
+### File Glob Pattern Examples:
+
+::: warning
+Glob patterns only apply when loading data from S3 as source.
+:::
+
+The `<file-glob-pattern>` in the `--source-table` argument allows for flexible file selection. Here are some common patterns and their descriptions:
+
+| Pattern                                     | Description                                                                                                |
+| :------------------------------------------ | :--------------------------------------------------------------------------------------------------------- |
+| `bucket/**/*.csv`                           | Retrieves all CSV files recursively from `s3://bucket`.                                                    |
+| `bucket/*.csv`                              | Retrieves all CSV files located at the root level of `s3://bucket`.                                        |
+| `bucket/myFolder/**/*.jsonl`                | Retrieves all JSONL files recursively from the `myFolder` directory and its subdirectories in `s3://bucket`. |
+| `bucket/myFolder/mySubFolder/users.parquet` | Retrieves the specific `users.parquet` file from the `myFolder/mySubFolder/` path in `s3://bucket`.        |
+| `bucket/employees.jsonl`                    | Retrieves the `employees.jsonl` file located at the root level of the `s3://bucket`.                       |

ingestr-0.13.49/docs/supported-sources/smartsheets.md

@@ -0,0 +1,47 @@
+# Smartsheet
+
+[Smartsheet](https://www.smartsheet.com/) is a software as a service (SaaS) offering for collaboration and work management.
+
+ingestr supports Smartsheet as a source.
+
+## URI format
+
+The URI format for Smartsheet is as follows:
+
+```plaintext
+smartsheet://?access_token=<access_token>
+```
+
+URI parameters:
+
+- `access_token`: Your Smartsheet API access token.
+
+The URI is used to connect to the Smartsheet API for extracting data. You can generate an access token in Smartsheet by navigating to Account > Personal Settings > API Access.
+
+## Setting up a Smartsheet Integration
+
+To set up a Smartsheet integration, you'll need an API Access Token.
+
+1. Log in to Smartsheet.
+2. Click on "Account" in the bottom left corner, then "Personal Settings".
+3. Go to the "API Access" tab.
+4. Click "Generate new access token".
+5. Give your token a name and click "OK".
+6. Copy the generated token. This will be your `access_token`.
+
+The source table you'll use for ingestr will be the `sheet_id` of the Smartsheet you want to ingest. You can find the `sheet_id` by opening the sheet in Smartsheet and going to File > Properties. The Sheet ID will be listed there.
+
+Let's say your access token is `llk2k3j4l5k6j7h8g9f0` and the sheet ID is `1234567890123456`, here's a sample command that will copy the data from Smartsheet into a DuckDB database:
+
+```sh
+ingestr ingest \
+    --source-uri 'smartsheet://?access_token=llk2k3j4l5k6j7h8g9f0' \
+    --source-table '1234567890123456' \
+    --dest-uri 'duckdb:///smartsheet_data.duckdb' \
+    --dest-table 'des.my_sheet_data'
+```
+
+The result of this command will be a `my_sheet_data` table containing data from your Smartsheet in the `smartsheet_data.duckdb` database.
+
+> [!CAUTION]
+> Smartsheet integration does not currently support incremental loading. Every time you run the command, the entire sheet will be copied from Smartsheet to the destination. This can be slow for large sheets. 

ingestr-0.13.49/docs/supported-sources/solidgate.md

@@ -0,0 +1,46 @@
+# Solidgate
+
+[Solidgate](https://solidgate.com//) is a one-stop payment processing platform that ensures seamless online purchases and streamlined payment infrastructure.
+
+ingestr supports Solidgate as a source.
+
+## URI format
+
+The URI format for Solidgate is as follows:
+
+```plaintext
+solidgate://?public_key=<your-public-key>&secret_key=<your-secret-key>
+```
+
+URI parameters:
+
+- `public_key`: The public API key used to identify the account.
+
+- `secret_key`: The secret API key used to authenticate requests to the Solidgate API.
+
+
+## Setting up a Solidgate Integration
+
+Solidgate requires a few steps to set up an integration. Please follow the [guide](https://docs.solidgate.com/payments/integrate/access-to-api/#retrieve-your-credentials).
+
+Once you complete the guide, you should have `public_key` and `secret_key`, here’s a sample command that ingests data from Solidgate into a DuckDB database:
+
+```sh
+ingestr ingestr ingest \
+--source-uri "solidgate://?public_key=api_pk_test&secret_key=api_sk_test" \
+--source-table "apm-orders" \
+--dest-uri "duckdb:///solidgate.db" \
+--dest-table "dest.apmorders"
+```
+
+The result of this command will be a table in the `Solidgate.duckdb` database with JSON columns.
+
+## Tables
+
+Solidgate source allows ingesting the following sources into separate tables:
+- `subscriptions`: Provides a comprehensive view of customer subscriptions, including subscription IDs, statuses, and key timestamps such as creation, update, and expiration dates.
+- `apm-orders`: Provides essential information for anti-fraud purposes, including order IDs, transaction statuses, amounts, currencies, and payment methods, along with crucial customer details such as email addresses.
+- `card-orders`: Provides detailed information on orders processed via card payments, including transaction data, payment status, and customer details.
+
+Use these as `--source-table` parameter in the `ingestr ingest` command.
+

{ingestr-0.13.47 → ingestr-0.13.49}/ingestr/main.py

@@ -290,6 +290,7 @@ def ingest(
     from ingestr.src.destinations import AthenaDestination
     from ingestr.src.factory import SourceDestinationFactory
     from ingestr.src.filters import cast_set_to_list, handle_mysql_empty_dates
+    from ingestr.src.sources import MongoDbSource
 
     def report_errors(run_info: LoadInfo):
         for load_package in run_info.load_packages:
@@ -537,6 +538,13 @@ def ingest(
         if yield_limit:
             resource.for_each(dlt_source, lambda x: x.add_limit(yield_limit))
 
+        if isinstance(source, MongoDbSource):
+            from ingestr.src.resource import TypeHintMap
+
+            resource.for_each(
+                dlt_source, lambda x: x.add_map(TypeHintMap().type_hint_map)
+            )
+
         def col_h(x):
             if column_hints:
                 x.apply_hints(columns=column_hints)

ingestr-0.13.49/ingestr/src/buildinfo.py

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

{ingestr-0.13.47 → ingestr-0.13.49}/ingestr/src/factory.py

@@ -54,6 +54,7 @@ from ingestr.src.sources import (
     SalesforceSource,
     ShopifySource,
     SlackSource,
+    SolidgateSource,
     SqlSource,
     StripeAnalyticsSource,
     TikTokSource,
@@ -159,6 +160,7 @@ class SourceDestinationFactory:
         "phantombuster": PhantombusterSource,
         "elasticsearch": ElasticsearchSource,
         "attio": AttioSource,
+        "solidgate": SolidgateSource,
     }
     destinations: Dict[str, Type[DestinationProtocol]] = {
         "bigquery": BigQueryDestination,

{ingestr-0.13.47 → ingestr-0.13.49}/ingestr/src/mongodb/__init__.py

@@ -14,7 +14,7 @@ from .helpers import (
 )
 
 
-@dlt.source
+@dlt.source(max_table_nesting=0)
 def mongodb(
     connection_url: str = dlt.secrets.value,
     database: Optional[str] = dlt.config.value,
@@ -75,6 +75,7 @@ def mongodb(
             primary_key="_id",
             write_disposition=write_disposition,
             spec=MongoDbCollectionConfiguration,
+            max_table_nesting=0,
         )(
             client,
             collection,

ingestr-0.13.49/ingestr/src/resource.py

@@ -0,0 +1,40 @@
+from typing import Callable
+
+from dlt.sources import DltResource, DltSource
+
+
+def for_each(
+    source: DltSource | DltResource, ex: Callable[[DltResource], None | DltResource]
+):
+    """
+    Apply a function to each resource in a source.
+    """
+    if hasattr(source, "selected_resources") and source.selected_resources:
+        resource_names = list(source.selected_resources.keys())
+        for res in resource_names:
+            ex(source.resources[res])  # type: ignore[union-attr]
+    else:
+        ex(source)  # type: ignore[arg-type]
+
+
+class TypeHintMap:
+    def __init__(self):
+        self.handled_typehints = False
+
+    def type_hint_map(self, item):
+        if self.handled_typehints:
+            return item
+
+        array_cols = []
+        for col in item:
+            if isinstance(item[col], (list, tuple)):
+                array_cols.append(col)
+        if array_cols:
+            import dlt
+
+            source = dlt.current.source()
+            columns = [{"name": col, "data_type": "json"} for col in array_cols]
+            for_each(source, lambda x: x.apply_hints(columns=columns))
+
+        self.handled_typehints = True
+        return item

ingestr-0.13.49/ingestr/src/smartsheets/__init__.py

@@ -0,0 +1,54 @@
+from typing import Iterable
+
+import dlt
+import smartsheet  # type: ignore
+from dlt.extract import DltResource
+
+
+@dlt.source
+def smartsheet_source(
+    access_token: str,
+    sheet_id: str,
+) -> Iterable[DltResource]:
+    """
+    A DLT source for Smartsheet.
+
+    Args:
+        access_token: The Smartsheet API access token.
+        sheet_id: The ID of the sheet to load.
+
+    Returns:
+        An iterable of DLT resources.
+    """
+
+    # Initialize Smartsheet client
+    smartsheet_client = smartsheet.Smartsheet(access_token)
+    smartsheet_client.errors_as_exceptions(True)
+
+    # The SDK expects sheet_id to be an int
+    sheet_id_int = int(sheet_id)
+    # Sanitize the sheet name to be a valid resource name
+    # We get objectValue to ensure `name` attribute is populated for the sheet
+    sheet_details = smartsheet_client.Sheets.get_sheet(
+        sheet_id_int, include=["objectValue"]
+    )
+    sheet_name = sheet_details.name
+    resource_name = f"sheet_{sheet_name.replace(' ', '_').lower()}"
+
+    yield dlt.resource(
+        _get_sheet_data(smartsheet_client, sheet_id_int),
+        name=resource_name,
+        write_disposition="replace",
+    )
+
+
+def _get_sheet_data(smartsheet_client: smartsheet.Smartsheet, sheet_id: int):
+    """Helper function to get all rows from a sheet."""
+    sheet = smartsheet_client.Sheets.get_sheet(sheet_id)
+    # Transform rows to a list of dictionaries
+    column_titles = [col.title for col in sheet.columns]
+    for row in sheet.rows:
+        row_data = {}
+        for i, cell in enumerate(row.cells):
+            row_data[column_titles[i]] = cell.value
+        yield row_data

ingestr-0.13.49/ingestr/src/solidgate/__init__.py

@@ -0,0 +1,97 @@
+from typing import Iterable, Iterator
+
+import dlt
+import pendulum
+from dlt.sources import DltResource
+
+from .helpers import SolidgateClient
+
+
+@dlt.source(max_table_nesting=0)
+def solidgate_source(
+    start_date: pendulum.DateTime,
+    end_date: pendulum.DateTime | None,
+    public_key: str,
+    secret_key: str,
+) -> Iterable[DltResource]:
+    solidgate_client = SolidgateClient(public_key, secret_key)
+
+    @dlt.resource(
+        name="subscriptions",
+        write_disposition="merge",
+        primary_key="id",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_all_subscriptions(
+        dateTime=dlt.sources.incremental(
+            "updated_at",
+            initial_value=start_date,
+            end_value=end_date,
+            range_start="closed",
+            range_end="closed",
+        ),
+    ) -> Iterator[dict]:
+        path = "subscriptions"
+        if dateTime.end_value is None:
+            end_dt = pendulum.now(tz="UTC")
+        else:
+            end_dt = dateTime.end_value
+
+        start_dt = dateTime.last_value
+        yield solidgate_client.fetch_data(path, date_from=start_dt, date_to=end_dt)
+
+    @dlt.resource(
+        name="apm-orders",
+        write_disposition="merge",
+        primary_key="order_id",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_apm_orders(
+        dateTime=dlt.sources.incremental(
+            "updated_at",
+            initial_value=start_date,
+            end_value=end_date,
+            range_start="closed",
+            range_end="closed",
+        ),
+    ) -> Iterator[dict]:
+        path = "apm-orders"
+        if dateTime.end_value is None:
+            end_dt = pendulum.now(tz="UTC")
+        else:
+            end_dt = dateTime.end_value
+
+        start_dt = dateTime.last_value
+        yield solidgate_client.fetch_data(path, date_from=start_dt, date_to=end_dt)
+
+    @dlt.resource(
+        name="card-orders",
+        write_disposition="merge",
+        primary_key="order_id",
+        columns={
+            "created_at": {"data_type": "timestamp", "partition": True},
+        },
+    )
+    def fetch_card_orders(
+        dateTime=dlt.sources.incremental(
+            "updated_at",
+            initial_value=start_date,
+            end_value=end_date,
+            range_start="closed",
+            range_end="closed",
+        ),
+    ) -> Iterator[dict]:
+        path = "card-orders"
+        if dateTime.end_value is None:
+            end_dt = pendulum.now(tz="UTC")
+        else:
+            end_dt = dateTime.end_value
+
+        start_dt = dateTime.last_value
+        yield solidgate_client.fetch_data(path, date_from=start_dt, date_to=end_dt)
+
+    return fetch_all_subscriptions, fetch_apm_orders, fetch_card_orders

ingestr-0.13.49/ingestr/src/solidgate/helpers.py

@@ -0,0 +1,74 @@
+import base64
+import hashlib
+import hmac
+import json
+
+import pendulum
+
+from ingestr.src.http_client import create_client
+
+
+class SolidgateClient:
+    def __init__(self, public_key, secret_key):
+        self.base_url = "https://reports.solidgate.com/api/v1"
+        self.public_key = public_key
+        self.secret_key = secret_key
+        self.client = create_client()
+
+    def fetch_data(
+        self,
+        path: str,
+        date_from: pendulum.DateTime,
+        date_to: pendulum.DateTime,
+    ):
+        request_payload = {
+            "date_from": date_from.format("YYYY-MM-DD HH:mm:ss"),
+            "date_to": date_to.format("YYYY-MM-DD HH:mm:ss"),
+        }
+
+        json_string = json.dumps(request_payload)
+        signature = self.generateSignature(json_string)
+        headers = {
+            "merchant": self.public_key,
+            "Signature": signature,
+            "Content-Type": "application/json",
+        }
+
+        next_page_iterator = None
+        url = f"{self.base_url}/{path}"
+
+        while True:
+            payload = request_payload.copy()
+            if next_page_iterator:
+                payload["page_iterator"] = next_page_iterator
+
+            response = self.client.post(url, headers=headers, json=payload)
+            response.raise_for_status()
+            response_json = response.json()
+
+            if path == "subscriptions":
+                data = response_json["subscriptions"]
+                for _, value in data.items():
+                    if "updated_at" in value:
+                        value["updated_at"] = pendulum.parse(value["updated_at"])
+                    yield value
+
+            else:
+                data = response_json["orders"]
+                for value in data:
+                    if "updated_at" in value:
+                        value["updated_at"] = pendulum.parse(value["updated_at"])
+                    yield value
+
+            next_page_iterator = response_json.get("metadata", {}).get(
+                "next_page_iterator"
+            )
+            if not next_page_iterator or next_page_iterator == "None":
+                break
+
+    def generateSignature(self, json_string):
+        data = self.public_key + json_string + self.public_key
+        hmac_hash = hmac.new(
+            self.secret_key.encode("utf-8"), data.encode("utf-8"), hashlib.sha512
+        ).digest()
+        return base64.b64encode(hmac_hash.hex().encode("utf-8")).decode("utf-8")