truto-python-sdk 0.1.0__py3-none-any.whl

truto_python_sdk/__init__.py

@@ -0,0 +1,16 @@
+# truto_python_sdk/__init__.py
+
+"""
+truto_python_sdk
+~~~~~~~~~~~~~~~~
+
+A Python3 SDK for the Truto API.
+"""
+
+__title__ = 'truto_python_sdk'
+__version__ = '0.1.0'
+__author__ = 'Roopendra Talekar <roopendra@truto.dev>'
+__license__ = 'MIT'
+__copyright__ = 'Copyright 2023 Yin Yang Inc.'
+
+from .truto_api import TrutoApi

truto_python_sdk/base_resource.py

@@ -0,0 +1,25 @@
+from .pagination_result import PaginationResult
+
+class BaseResource:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all base_resources with pagination support."""
+        return PaginationResult(self.api_client, "base_resource", query_params)
+
+    def get(self, base_resource_id: str):
+        """Get a specific base_resource by ID."""
+        return self.api_client._get(f"base_resource/{base_resource_id}")
+
+    def create(self, base_resource_data: dict):
+        """Create a new base_resource."""
+        return self.api_client._post("base_resource", data=base_resource_data)
+
+    def update(self, base_resource_id: str, base_resource_data: dict):
+        """Update an existing base_resource."""
+        return self.api_client._patch(f"base_resource/{base_resource_id}", data=base_resource_data)
+
+    def delete(self, base_resource_id: str):
+        """Delete a base_resource by ID."""
+        return self.api_client._delete(f"base_resource/{base_resource_id}")

truto_python_sdk/dict_to_query_string.py

@@ -0,0 +1,44 @@
+from urllib.parse import urlencode, quote_plus
+import datetime
+
+
+def _convert_to_query_params(prefix, data):
+    """
+    Recursively convert a Python dictionary, list, or primitive into a valid
+    HTTP query parameter string.
+    """
+    params = []
+
+    if isinstance(data, dict):
+        # Recursively handle dictionaries (objects)
+        for key, value in data.items():
+            new_prefix = f"{prefix}[{key}]" if prefix else key
+            params.extend(_convert_to_query_params(new_prefix, value))
+    elif isinstance(data, list):
+        # Handle lists (arrays)
+        for item in data:
+            new_prefix = f"{prefix}[]"
+            params.extend(_convert_to_query_params(new_prefix, item))
+    else:
+        # Base case for strings, numbers, booleans, and date/time
+        if isinstance(data, (datetime.date, datetime.datetime)):
+            # Convert date/time to ISO 8601 format
+            data = data.isoformat()
+        elif isinstance(data, bool):
+            # Convert booleans to lowercase string "true" or "false"
+            data = str(data).lower()
+
+        params.append((prefix, data))
+
+    return params
+
+
+def dict_to_query_string(data):
+    """
+    Convert a Python dictionary into a valid HTTP query string with proper encoding.
+    """
+    query_params = []
+    for key, value in data.items():
+        query_params.extend(_convert_to_query_params(key, value))
+
+    return urlencode(query_params, doseq=True, quote_via=quote_plus)

truto_python_sdk/environment.py

@@ -0,0 +1,13 @@
+from .pagination_result import PaginationResult
+
+class Environment:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all environments with pagination support."""
+        return PaginationResult(self.api_client, "environment", query_params)
+
+    def get(self, environment_id: str):
+        """Get a specific environment by ID."""
+        return self.api_client._get(f"environment/{environment_id}")

truto_python_sdk/environment_integration.py

@@ -0,0 +1,17 @@
+from .pagination_result import PaginationResult
+
+class EnvironmentIntegration:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all environment integrations with pagination support."""
+        return PaginationResult(self.api_client, "environment-integration", query_params)
+
+    def get(self, environment_integration_id: str):
+        """Get a specific environment_integration by ID."""
+        return self.api_client._get(f"environment-integration/{environment_integration_id}")
+
+    def update(self, environment_integration_id: str, environment_integration_data: dict):
+        """Update an existing environment_integration."""
+        return self.api_client._patch(f"environment-integration/{environment_integration_id}", data=environment_integration_data)

truto_python_sdk/environment_unified_model.py

@@ -0,0 +1,17 @@
+from .pagination_result import PaginationResult
+
+class EnvironmentUnifiedModel:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all environment unified models with pagination support."""
+        return PaginationResult(self.api_client, "environment-unified-model", query_params)
+
+    def get(self, environment_unified_model_id: str):
+        """Get a specific environment_unified_model by ID."""
+        return self.api_client._get(f"environment-unified-model/{environment_unified_model_id}")
+
+    def update(self, environment_unified_model_id: str, environment_unified_model_data: dict):
+        """Update an existing environment_unified_model."""
+        return self.api_client._patch(f"environment-unified-model/{environment_unified_model_id}", data=environment_unified_model_data)

truto_python_sdk/integrated_account.py

@@ -0,0 +1,37 @@
+from .pagination_result import PaginationResult
+
+class IntegratedAccount:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all integrated_accounts with pagination support."""
+        return PaginationResult(self.api_client, "integrated-account", query_params)
+
+    def get(self, integrated_account_id: str):
+        """Get a specific integrated_account by ID."""
+        return self.api_client._get(f"integrated-account/{integrated_account_id}")
+
+    def _import(self, integrated_account_data: dict):
+        """Create a new integrated_account."""
+        return self.api_client._post("integrated-account", data=integrated_account_data)
+
+    def update(self, integrated_account_id: str, integrated_account_data: dict):
+        """Update an existing integrated_account."""
+        return self.api_client._patch(f"integrated-account/{integrated_account_id}", data=integrated_account_data)
+
+    def delete(self, integrated_account_id: str):
+        """Delete an integrated_account by ID."""
+        return self.api_client._delete(f"integrated-account/{integrated_account_id}")
+
+    def create_integrated_account_token(self, integrated_account_id: str):
+        """Create a new token for the integrated account."""
+        return self.api_client._post(f"integrated-account/token", data={"integrated_account_id": integrated_account_id})
+
+    def refresh_credentials(self, integrated_account_id: str):
+        """Refresh the credentials for the integrated account."""
+        return self.api_client._post(f"integrated-account/refresh-credentials", data={"id": integrated_account_id})
+
+    def run_post_install_actions(self, integrated_account_id: str):
+        """Run post install actions for the integrated account."""
+        return self.api_client._post(f"integrated-account/run-post-install-actions", data={"id": integrated_account_id})

truto_python_sdk/integration.py

@@ -0,0 +1,33 @@
+from .pagination_result import PaginationResult
+
+class Integration:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all integrations with pagination support."""
+        return PaginationResult(self.api_client, "integration", query_params)
+
+    def get(self, integration_id: str):
+        """Get a specific integration by ID."""
+        return self.api_client._get(f"integration/{integration_id}")
+
+    def create(self, integration_data: dict):
+        """Create a new integration."""
+        return self.api_client._post("integration", data=integration_data)
+
+    def update(self, integration_id: str, integration_data: dict):
+        """Update an existing integration."""
+        return self.api_client._patch(f"integration/{integration_id}", data=integration_data)
+
+    def delete(self, integration_id: str):
+        """Delete an integration by ID."""
+        return self.api_client._delete(f"integration/{integration_id}")
+
+    def install(self, integration_id: str, is_enabled: bool = True):
+        """Install an integration by ID."""
+        return self.api_client._post(f"environment-integration", data={"integration_id": integration_id, "is_enabled": is_enabled})
+
+    def uninstall(self, integration_id: str):
+        """Uninstall an integration by ID."""
+        return self.api_client._delete(f"environment-integration/{integration_id}")

truto_python_sdk/link_token.py

@@ -0,0 +1,17 @@
+from typing import TypedDict
+
+class LinkTokenCreateBody(TypedDict, total=False):
+    tenant_id: str # When connecting a new integrated account, this is required.
+    integrated_account_id: str # When reconnecting an existing integrated account, this is required.
+    redirect_uri: str # The URL to redirect to after the user has completed the connect flow. Useful if you are authenticating via a Desktop app
+    context: dict # A dictionary of key-value pairs that will be stored in the integrated account's context attribute.
+    persist_previous_context: bool # If true, the context attribute of the integrated account will be retained when reconnecting the account. If false, the context attribute will be reset.
+    environment_unified_model_id: str # Only works if the integration you want to connect follows OAuth 2.0. This option sets the scopes to ask for depending on the Unified API you want to use.
+
+class LinkToken:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def create(self, link_token_data: LinkTokenCreateBody):
+        """Create a new link_token."""
+        return self.api_client._post("link-token", data=link_token_data)

truto_python_sdk/pagination_result.py

@@ -0,0 +1,60 @@
+# truto_sdk/pagination_result.py
+
+class PaginationResult:
+    def __init__(self, api_client, endpoint, query_params):
+        self.api_client = api_client
+        self.endpoint = endpoint
+        self.query_params = query_params
+        self.next_cursor = None
+        self.items = []
+        self.initial_fetch_done = False  # To check if we fetched the first page
+
+    def __aiter__(self):
+        return self
+
+    async def __anext__(self):
+        # If the first fetch is not done, do it now
+        if not self.initial_fetch_done:
+            await self._fetch_next_page()
+            self.initial_fetch_done = True
+
+        # If no items are left in the current page and there's a next_cursor, fetch the next page
+        if not self.items and self.next_cursor:
+            await self._fetch_next_page()
+
+        # If there are no items and no next_cursor, stop iteration
+        if not self.items:
+            raise StopAsyncIteration
+
+        # Pop and return the first item from the items list
+        return self.items.pop(0)
+
+    async def _fetch_next_page(self):
+        # If there's a next cursor, include it in the query parameters
+        if self.next_cursor:
+            self.query_params['next_cursor'] = self.next_cursor
+
+        # Fetch the next page asynchronously
+        response = await self.api_client._get(self.endpoint, params=self.query_params)
+
+        # Get the result (list of items) from the response
+        self.items = response.get('result', [])
+
+        # Update the next cursor for pagination
+        self.next_cursor = response.get('next_cursor')
+
+        # If the first API call returns an empty result and no next_cursor, break early
+        if not self.items and not self.next_cursor:
+            self.items = []  # Ensure no more items will be processed
+
+    async def to_array(self):
+        """Fetch all results and return them as a list."""
+        all_items = []
+        async for item in self:
+            all_items.append(item)
+        return all_items
+
+    async def next_page(self):
+        """Fetch the next page and return the items."""
+        await self._fetch_next_page()
+        return self.items

truto_python_sdk/proxy_api.py

@@ -0,0 +1,29 @@
+from .pagination_result import PaginationResult
+
+class ProxyApi:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, resource: str, query_params: dict):
+        """List all proxy api resources with pagination support."""
+        return PaginationResult(self.api_client, f"proxy/{resource}", query_params)
+
+    def get(self, resource: str, id: str, query_params: dict):
+        """Get a specific proxy api resource by ID."""
+        return self.api_client._get(f"proxy/{resource}/{id}", params=query_params)
+
+    def create(self, resource: str, data: dict, query_params: dict):
+        """Create a new proxy api resource."""
+        return self.api_client._post(f"proxy/{resource}", data=data, params=query_params)
+
+    def update(self, resource: str, id: str, data: dict, query_params: dict):
+        """Update an existing proxy api resource."""
+        return self.api_client._patch(f"proxy/{resource}/{id}", data=data, params=query_params)
+
+    def delete(self, resource: str, id: str, query_params: dict):
+        """Delete a proxy api resource by ID."""
+        return self.api_client._delete(f"proxy/{resource}/{id}", query_params)
+
+    def custom_method(self, resource: str, method: str, data: dict, query_params: dict):
+        """Call a custom method on a proxy api resource."""
+        return self.api_client._post(method, f"proxy/{resource}/{method}", data=data, params=query_params)

truto_python_sdk/sync_job.py

@@ -0,0 +1,25 @@
+from .pagination_result import PaginationResult
+
+class SyncJob:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all sync jobs with pagination support."""
+        return PaginationResult(self.api_client, "sync-job", query_params)
+
+    def get(self, sync_job_id: str):
+        """Get a specific sync_job by ID."""
+        return self.api_client._get(f"sync-job/{sync_job_id}")
+
+    def create(self, sync_job_data: dict):
+        """Create a new sync_job."""
+        return self.api_client._post("sync-job", data=sync_job_data)
+
+    def update(self, sync_job_id: str, sync_job_data: dict):
+        """Update an existing sync_job."""
+        return self.api_client._patch(f"sync-job/{sync_job_id}", data=sync_job_data)
+
+    def delete(self, sync_job_id: str):
+        """Delete an sync_job by ID."""
+        return self.api_client._delete(f"sync-job/{sync_job_id}")

truto_python_sdk/sync_job_cron_trigger.py

@@ -0,0 +1,29 @@
+from .pagination_result import PaginationResult
+
+class SyncJobCronTrigger:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all sync job cron triggers with pagination support."""
+        return PaginationResult(self.api_client, "sync-job-cron-trigger", query_params)
+
+    def get(self, sync_job_cron_trigger_id: str):
+        """Get a specific sync_job_cron_trigger by ID."""
+        return self.api_client._get(f"sync-job-cron-trigger/{sync_job_cron_trigger_id}")
+
+    def create(self, sync_job_cron_trigger_data: dict):
+        """Create a new sync_job_cron_trigger."""
+        return self.api_client._post("sync-job-cron-trigger", data=sync_job_cron_trigger_data)
+
+    def update(self, sync_job_cron_trigger_id: str, sync_job_cron_trigger_data: dict):
+        """Update an existing sync_job_cron_trigger."""
+        return self.api_client._patch(f"sync-job-cron-trigger/{sync_job_cron_trigger_id}", data=sync_job_cron_trigger_data)
+
+    def delete(self, sync_job_cron_trigger_id: str):
+        """Delete an sync_job_cron_trigger by ID."""
+        return self.api_client._delete(f"sync-job-cron-trigger/{sync_job_cron_trigger_id}")
+
+    def schedule(self, sync_job_cron_trigger_id: str):
+        """Schedule a sync job cron trigger by ID."""
+        return self.api_client._post(f"sync-job-cron-trigger/{sync_job_cron_trigger_id}/schedule")

truto_python_sdk/sync_job_run.py

@@ -0,0 +1,25 @@
+from .pagination_result import PaginationResult
+
+class SyncJobRun:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all sync job runs with pagination support."""
+        return PaginationResult(self.api_client, "sync-job-run", query_params)
+
+    def get(self, sync_job_run_id: str):
+        """Get a specific sync_job_run by ID."""
+        return self.api_client._get(f"sync-job-run/{sync_job_run_id}")
+
+    def create(self, sync_job_run_data: dict):
+        """Create a new sync_job_run."""
+        return self.api_client._post("sync-job-run", data=sync_job_run_data)
+
+    def update(self, sync_job_run_id: str, sync_job_run_data: dict):
+        """Update an existing sync_job_run."""
+        return self.api_client._patch(f"sync-job-run/{sync_job_run_id}", data=sync_job_run_data)
+
+    def delete(self, sync_job_run_id: str):
+        """Delete an sync_job_run by ID."""
+        return self.api_client._delete(f"sync-job-run/{sync_job_run_id}")

truto_python_sdk/team.py

@@ -0,0 +1,13 @@
+from .pagination_result import PaginationResult
+
+class Team:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all teams with pagination support."""
+        return PaginationResult(self.api_client, "team", query_params)
+
+    def get(self, team_id: str):
+        """Get a specific team by ID."""
+        return self.api_client._get(f"team/{team_id}")

truto_python_sdk/truto_api.py

@@ -0,0 +1,101 @@
+import aiohttp
+
+from .dict_to_query_string import dict_to_query_string
+from .environment import Environment
+from .environment_integration import EnvironmentIntegration
+from .integrated_account import IntegratedAccount
+from .integration import Integration
+from .link_token import LinkToken
+from .proxy_api import ProxyApi
+from .sync_job import SyncJob
+from .sync_job_cron_trigger import SyncJobCronTrigger
+from .sync_job_run import SyncJobRun
+from .team import Team
+from .unified_api import UnifiedApi
+from .user import User
+from .unified_model import UnifiedModel
+from .environment_unified_model import EnvironmentUnifiedModel
+from .webhook import Webhook
+
+
+class TrutoApi:
+    def __init__(self, token: str, base_url: str = 'https://api.truto.one'):
+        self.token = token
+        self.base_url = base_url
+        self.headers = {
+            "Authorization": f"Bearer {self.token}",
+            "Content-Type": "application/json",
+            "Accept": "application/json"
+        }
+        self.users = User(self)
+        self.teams = Team(self)
+        self.environments = Environment(self)
+        self.link_tokens = LinkToken(self)
+        self.integrated_accounts = IntegratedAccount(self)
+        self.integrations = Integration(self)
+        self.environment_integrations = EnvironmentIntegration(self)
+        self.unified_models = UnifiedModel(self)
+        self.environment_unified_models = EnvironmentUnifiedModel(self)
+        self.sync_jobs = SyncJob(self)
+        self.sync_job_runs = SyncJobRun(self)
+        self.sync_job_cron_triggers = SyncJobCronTrigger(self)
+        self.webhooks = Webhook(self)
+        self.unified_api = UnifiedApi(self)
+        self.proxy_api = ProxyApi(self)
+
+    async def _process_response(self, response):
+        # Get the Content-Type header
+        content_type = response.headers.get('Content-Type', '').lower()
+
+        if 'json' in content_type:
+            # If it's a JSON-like content type (application/json, text/json, etc.)
+            return await response.json()
+        elif content_type.startswith('text/'):
+            # If it's any kind of text (e.g., text/plain, text/html)
+            return await response.text()
+        else:
+            # For everything else (binary data, unknown types)
+            return await response.read()
+
+    async def _get(self, endpoint, params=None):
+        url = f"{self.base_url}/{endpoint}"
+        query_string = dict_to_query_string(params) if params else ""
+        async with aiohttp.ClientSession() as session:
+            async with session.get(f"{url}?{query_string}", headers=self.headers) as response:
+                response.raise_for_status()
+                return await self._process_response(response)
+
+    async def _post(self, endpoint, data=None, params=None):
+        url = f"{self.base_url}/{endpoint}"
+        query_string = dict_to_query_string(params) if params else ""
+        async with aiohttp.ClientSession() as session:
+            async with session.post(f"{url}?{query_string}", headers=self.headers, json=data) as response:
+                response.raise_for_status()
+                return await self._process_response(response)
+
+    async def _patch(self, endpoint, data=None, params=None):
+        url = f"{self.base_url}/{endpoint}"
+        query_string = dict_to_query_string(params) if params else ""
+        async with aiohttp.ClientSession() as session:
+            async with session.patch(f"{url}?{query_string}", headers=self.headers, json=data) as response:
+                response.raise_for_status()
+                return await self._process_response(response)
+
+    async def _put(self, endpoint, data=None, params=None):
+        url = f"{self.base_url}/{endpoint}"
+        query_string = dict_to_query_string(params) if params else ""
+        async with aiohttp.ClientSession() as session:
+            async with session.put(f"{url}?{query_string}", headers=self.headers, json=data) as response:
+                response.raise_for_status()
+                return await self._process_response(response)
+
+    async def _delete(self, endpoint, params=None):
+        url = f"{self.base_url}/{endpoint}"
+        query_string = dict_to_query_string(params) if params else ""
+        async with aiohttp.ClientSession() as session:
+            async with session.delete(f"{url}?{query_string}", headers=self.headers) as response:
+                response.raise_for_status()
+                return await self._process_response(response)
+
+    async def ping(self):
+        return await self._get("ping")

truto_python_sdk/unified_api.py

@@ -0,0 +1,29 @@
+from .pagination_result import PaginationResult
+
+class UnifiedApi:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, unified_model_name: str, unified_model_resource: str, query_params: dict):
+        """List all unified api resources with pagination support."""
+        return PaginationResult(self.api_client, f"unified/{unified_model_name}/{unified_model_resource}", query_params)
+
+    def get(self, unified_model_name: str, unified_model_resource: str, id: str, query_params: dict):
+        """Get a specific unified api resource by ID."""
+        return self.api_client._get(f"unified/{unified_model_name}/{unified_model_resource}/{id}", query_params)
+
+    def create(self, unified_model_name: str, unified_model_resource: str, data: dict, query_params: dict):
+        """Create a new unified api resource."""
+        return self.api_client._post(f"unified/{unified_model_name}/{unified_model_resource}", data=data, params=query_params)
+
+    def update(self, unified_model_name: str, unified_model_resource: str, id: str, data: dict, query_params: dict):
+        """Update an existing unified api resource."""
+        return self.api_client._patch(f"unified/{unified_model_name}/{unified_model_resource}/{id}", data=data, params=query_params)
+
+    def delete(self, unified_model_name: str, unified_model_resource: str, id: str, query_params: dict):
+        """Delete an unified api resource by ID."""
+        return self.api_client._delete(f"unified/{unified_model_name}/{unified_model_resource}/{id}", query_params)
+
+    def custom_method(self, unified_model_name: str, unified_model_resource: str, method: str, data: dict, query_params: dict):
+        """Call a custom method on a unified api resource."""
+        return self.api_client._post(method, f"unified/{unified_model_name}/{unified_model_resource}/{method}", data=data, params=query_params)

truto_python_sdk/unified_model.py

@@ -0,0 +1,33 @@
+from .pagination_result import PaginationResult
+
+class UnifiedModel:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all unified models with pagination support."""
+        return PaginationResult(self.api_client, "unified-model", query_params)
+
+    def get(self, unified_model_id: str):
+        """Get a specific unified_model by ID."""
+        return self.api_client._get(f"unified-model/{unified_model_id}")
+
+    def create(self, unified_model_data: dict):
+        """Create a new unified_model."""
+        return self.api_client._post("unified-model", data=unified_model_data)
+
+    def update(self, unified_model_id: str, unified_model_data: dict):
+        """Update an existing unified_model."""
+        return self.api_client._patch(f"unified-model/{unified_model_id}", data=unified_model_data)
+
+    def delete(self, unified_model_id: str):
+        """Delete an unified_model by ID."""
+        return self.api_client._delete(f"unified-model/{unified_model_id}")
+
+    def install(self, unified_model_id: str):
+        """Install an unified_model by ID."""
+        return self.api_client._post(f"environment-unified-model", data={"unified_model_id": unified_model_id})
+
+    def uninstall(self, unified_model_id: str):
+        """Uninstall an unified_model by ID."""
+        return self.api_client._delete(f"environment-unified-model/{unified_model_id}")

truto_python_sdk/user.py

@@ -0,0 +1,13 @@
+from .pagination_result import PaginationResult
+
+class User:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all users with pagination support."""
+        return PaginationResult(self.api_client, "user", query_params)
+
+    def get(self, user_id: str):
+        """Get a specific user by ID."""
+        return self.api_client._get(f"user/{user_id}")

truto_python_sdk/webhook.py

@@ -0,0 +1,29 @@
+from .pagination_result import PaginationResult
+
+class Webhook:
+    def __init__(self, api_client):
+        self.api_client = api_client
+
+    def list(self, **query_params):
+        """List all webhooks with pagination support."""
+        return PaginationResult(self.api_client, "webhook", query_params)
+
+    def get(self, webhook_id: str):
+        """Get a specific webhook by ID."""
+        return self.api_client._get(f"webhook/{webhook_id}")
+
+    def create(self, webhook_data: dict):
+        """Create a new webhook."""
+        return self.api_client._post("webhook", data=webhook_data)
+
+    def update(self, webhook_id: str, webhook_data: dict):
+        """Update an existing webhook."""
+        return self.api_client._patch(f"webhook/{webhook_id}", data=webhook_data)
+
+    def delete(self, webhook_id: str):
+        """Delete a webhook by ID."""
+        return self.api_client._delete(f"webhook/{webhook_id}")
+
+    def test(self, webhook_id: str):
+        """Test a webhook by ID."""
+        return self.api_client._post(f"webhook/test", data={"id": webhook_id})

truto_python_sdk-0.1.0.dist-info/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Roopendra Talekar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

truto_python_sdk-0.1.0.dist-info/METADATA

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: truto-python-sdk
+Version: 0.1.0
+Summary: Python3 SDK for the Truto API
+Author: Roopendra Talekar
+Author-email: roopendratalekar@gmail.com
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: aiohttp (==3.10.5)
+Requires-Dist: asyncio (==3.4.3)
+Description-Content-Type: text/markdown
+
+# truto-python-sdk
+Python3 SDK for the Truto API
+

truto_python_sdk-0.1.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+truto_python_sdk/__init__.py,sha256=CPaEKamw1S6U0qJH96oNrrSmExVgQZ40pLnjc41E3Gg,316
+truto_python_sdk/base_resource.py,sha256=9pkj3gWmCU4tCWufTVJF27a4KTJ4QddEXKvibufhstc,1043
+truto_python_sdk/dict_to_query_string.py,sha256=jSbAZcmgKQ2wFmtlisQ9UqbGTPn_EUYpNyO0vHvKODM,1466
+truto_python_sdk/environment.py,sha256=TVVfVwslcOWVImwjsyCBp0JemGDXxvHCnUFNmysTWiw,474
+truto_python_sdk/environment_integration.py,sha256=CfpUMA-zB08uczypIsGTf99Ivh-Sm6dCXD1opiDTImU,837
+truto_python_sdk/environment_unified_model.py,sha256=EtGRV20GTWVe9XJ3neSxskhy-2SXOA27H3o-izi1CWY,862
+truto_python_sdk/integrated_account.py,sha256=fC11ehQLPP7n8jXnOfjWSqC-zElBVEehx6eKsrcePJI,1911
+truto_python_sdk/integration.py,sha256=YDC0dBwbEa57oJnPmCysZDPxwJa3SgJy1KpuLP6thcQ,1426
+truto_python_sdk/link_token.py,sha256=L58Fgjy26JukCNzLh7IpyW6qkbj7Q3bnFLy-CzdsWNE,1173
+truto_python_sdk/pagination_result.py,sha256=KwRT1s0F6RpNkW1D5WjDlGJxOewrreTmRVfuL73QCUI,2152
+truto_python_sdk/proxy_api.py,sha256=kLIM5qB0jncyS48XGxeKEsn1sYhweJaGmz3UEWhew74,1434
+truto_python_sdk/sync_job.py,sha256=7H1YxoZ3oW-hJnnmKVe1BCpolbXWxrgcpHUreTdFqa0,939
+truto_python_sdk/sync_job_cron_trigger.py,sha256=6ur3WKy17zP7_6Ox1_PwTdFFD6y8jaitpB4MCMPSRKg,1419
+truto_python_sdk/sync_job_run.py,sha256=Q7XTyyz6XOQRFYnSC0hcI1WjtrED7iIacEKtOfQ1zOU,1022
+truto_python_sdk/team.py,sha256=JnV6HO4nnYKY2iOipatBfzVlDKgo8VNj13-ESU9FKuE,425
+truto_python_sdk/truto_api.py,sha256=qKGVnm5vKa1Y_KyNeMIQS0cV8PN62aqL16gZu33kAWU,4544
+truto_python_sdk/unified_api.py,sha256=NquYiVCEIUIjB_a-8Ntv1lIFI-cCt4g2sAsVVAYa9EA,1898
+truto_python_sdk/unified_model.py,sha256=5bvnrn7JppXwwnsGd7F1klbNWhbF261_yRCGD0Gph8k,1434
+truto_python_sdk/user.py,sha256=756FsS96nql5D0ig7a_nUPnJgStP2Za_OHUuqz-T1OQ,425
+truto_python_sdk/webhook.py,sha256=eyTw98Whdj9kOaYV0LNgNpfol9_4uYa_QrbJP-iRSdo,1071
+truto_python_sdk-0.1.0.dist-info/LICENSE,sha256=l6HsZ8Od004T_53MFVmUGPU9WtTg3Lclh-deEnGp5pY,1074
+truto_python_sdk-0.1.0.dist-info/METADATA,sha256=uNuUTm_YJTMuzL4lWv0Sq2Mg7IyeZHzuJHFmldmDZ3I,452
+truto_python_sdk-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+truto_python_sdk-0.1.0.dist-info/RECORD,,

truto_python_sdk-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any