definite-sdk 0.1.15__tar.gz → 0.1.17__tar.gz

{definite_sdk-0.1.15 → definite_sdk-0.1.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: definite-sdk
-Version: 0.1.15
+Version: 0.1.17
 Summary: Definite SDK for Python
 License: MIT
 License-File: LICENSE

{definite_sdk-0.1.15 → definite_sdk-0.1.17}/definite_sdk/client.py

@@ -1,7 +1,6 @@
 import os
 from typing import Optional
 
-import requests
 from definite_sdk.integration import DefiniteIntegrationStore
 from definite_sdk.message import DefiniteMessageClient
 from definite_sdk.secret import DefiniteSecretStore
@@ -73,6 +72,7 @@ class DefiniteClient:
         This method fetches the team's DuckLake integration credentials and generates
         the necessary SQL statements to create a GCS secret and attach DuckLake.
 
+
         Args:
             alias: The alias name for the attached DuckLake database (default: "lake")
 
@@ -85,42 +85,38 @@ class DefiniteClient:
             >>> conn.execute(sql)
         """
         # Fetch DuckLake integration details
-        try:
-            response = requests.get(
-                f"{self.api_url}/v1/api/integration/Ducklake",
-                headers={"Authorization": f"Bearer {self.api_key}"},
+        integrations_client = self.get_integration_store()
+        integrations = integrations_client.list_integrations(
+            integration_type="ducklake"
+        )
+        if len(integrations) == 0:
+            raise Exception(
+                "DuckLake integration not found. Please make sure one is"
+                "created for your team at https://ui.definite.app/settings/integrations"
             )
-            response.raise_for_status()
-            dl_integration = response.json()
-        except requests.exceptions.HTTPError as e:
-            if response.status_code == 404:
-                raise ValueError(
-                    "DuckLake integration not found. Please ensure you have a DuckLake integration "
-                    "configured in your Definite account at https://ui.definite.app"
-                ) from e
-            else:
-                raise
+
+        integration = integrations.pop()
 
         # Generate SQL statements
         create_secret_sql = f"""CREATE SECRET (
-    TYPE gcs,
-    KEY_ID '{dl_integration['gcs_access_key_id']}',
-    SECRET '{dl_integration['gcs_secret_access_key']}'
-);"""
+            TYPE gcs,
+            KEY_ID '{integration["gcs_access_key_id"]}',
+            SECRET '{integration["gcs_secret_access_key"]}'
+        );"""
 
         # Build PostgreSQL connection string
         pg_conn_str = (
-            f"postgresql://{dl_integration['pg_user']}:"
-            f"{dl_integration['pg_password']}@"
-            f"{dl_integration['pg_host']}:"
-            f"{dl_integration['pg_port']}/"
-            f"{dl_integration['pg_database']}"
+            f"postgresql://{integration['pg_user']}:"
+            f"{integration['pg_password']}@"
+            f"{integration['pg_host']}:"
+            f"{integration['pg_port']}/"
+            f"{integration['pg_database']}"
         )
 
         attach_sql = (
             f"ATTACH 'ducklake:postgres:{pg_conn_str}' AS {alias} "
-            f"(DATA_PATH 'gs://{dl_integration['gcs_bucket_path']}', "
-            f"METADATA_SCHEMA '{dl_integration['pg_schema']}');"
+            f"(DATA_PATH 'gs://{integration['gcs_bucket_path']}', "
+            f"METADATA_SCHEMA '{integration['pg_schema']}');"
         )
 
         return f"{create_secret_sql}\n\n{attach_sql}"

definite_sdk-0.1.17/definite_sdk/integration.py

@@ -0,0 +1,190 @@
+from typing import Dict, List, Optional, cast
+
+import requests
+
+INTEGRATION_ENDPOINT = "/v1/api/integrations"
+
+
+class DefiniteIntegrationStore:
+    """
+    Read only access to the integration store on Definite.
+
+    Initialization:
+    >>> client = DefiniteSdkClient("MY_API_KEY")
+    >>> integration_store = client.get_integration_store()
+
+    Accessing values:
+    >>> integration_store.list_integrations()
+    >>> integration_store.get_integration("name")
+    >>> integration_store.get_integration_by_id("integration_id")
+    """
+
+    def __init__(self, api_key: str, api_url: str):
+        """
+        Initializes the DefiniteSecretStore
+
+        Args:
+            api_key (str): The API key for authorization.
+        """
+        self._api_key = api_key
+        self._integrations_url = api_url + INTEGRATION_ENDPOINT
+
+    def list_integrations(
+        self,
+        *,
+        integration_type: Optional[str] = None,
+        category: Optional[str] = None,
+    ) -> List[Dict]:
+        """
+        Lists all integrations in the store.
+
+        Args:
+            integration_type (str): Optional type filter
+            category (str): Optional category filter
+
+        Returns:
+            Iterator[str]: An iterator of integrations.
+        """
+        params = {}
+        if integration_type:
+            params |= {"type": integration_type}
+        if category:
+            params |= {"category": category}
+
+        response = requests.get(
+            self._integrations_url,
+            params=params,
+            headers={"Authorization": "Bearer " + self._api_key},
+        )
+        response.raise_for_status()
+        cursor_page = response.json()
+        integrations = cursor_page.get("data", [])
+        details = [i.get("details", {}) for i in integrations]
+        return cast(List[Dict], details)
+
+    def get_integration(self, name: str) -> Dict:
+        """
+        Retrieves an integration by name.
+
+        Args:
+            name (str): The name of the integration.
+
+        Returns:
+            str: The value of the integration.
+        """
+        response = requests.get(
+            self._integrations_url,
+            params={"name": name, "limit": 1},
+            headers={"Authorization": "Bearer " + self._api_key},
+        )
+        response.raise_for_status()
+        cursor_page = response.json()
+        integrations = cursor_page.get("data", [])
+        if len(integrations) == 0:
+            raise Exception(f"Integration with name {name} not found")
+        integration = integrations[0]
+        return integration.get("details", {})
+
+    def get_integration_by_id(self, integration_id: str) -> Dict:
+        """
+        Retrieves an integration by ID.
+
+        Args:
+            integration_id (str): The ID of the integration.
+
+        Returns:
+            dict: The integration details.
+        """
+        response = requests.get(
+            self._integrations_url,
+            params={"id": integration_id, "limit": 1},
+            headers={"Authorization": "Bearer " + self._api_key},
+        )
+        response.raise_for_status()
+        cursor_page = response.json()
+        integrations = cursor_page.get("data", [])
+        if len(integrations) == 0:
+            raise Exception(f"Integration with ID {integration_id} not found")
+        integration = integrations[0]
+        return integration.get("details", {})
+
+    def lookup_duckdb_integration(self) -> Dict:
+        """
+        Look up the team's DuckDB integration.
+
+        Returns:
+            Optional[Tuple[str, str]]: Tuple of (integration_id, connection_uri)
+                if found, None if no DuckDB integration exists.
+        """
+        response = requests.get(
+            self._integrations_url,
+            params={"type": "duckdb", "limit": 1},
+            headers={"Authorization": "Bearer " + self._api_key},
+        )
+        response.raise_for_status()
+        cursor_page = response.json()
+        integrations = cursor_page.get("data", [])
+        if len(integrations) == 0:
+            raise Exception("Integration with type `duckdb` not found")
+        integration = integrations[0]
+        return integration.get("details", {})
+
+    def get_syncs(
+        self,
+        integration_id: str,
+        *,
+        limit: int = 50,
+        offset: int = 0,
+        desc: bool = True,
+        status: Optional[str] = None,
+    ) -> List[Dict]:
+        """
+        Retrieves sync runs (DAG runs) for an integration.
+
+        Args:
+            integration_id (str): The ID of the integration.
+            limit (int): Maximum number of results to return (default: 50, max: 100).
+            offset (int): Number of results to skip for pagination (default: 0).
+            desc (bool): Sort by created_at descending if True (default: True).
+            status (str): Optional filter by status ("STARTED", "SUCCESS", "FAILED").
+
+        Returns:
+            List[Dict]: List of DAG run records with keys:
+                - dag_name: Name of the DAG
+                - run_id: Unique ID for this run
+                - created_at: ISO datetime when created
+                - updated_at: ISO datetime when updated
+                - src_integration_id: Source integration UUID
+                - dst_integration_id: Destination integration UUID
+                - status: Run status (STARTED, SUCCESS, FAILED)
+                - details: Additional run details
+        """
+        params: Dict = {
+            "limit": limit,
+            "offset": offset,
+            "desc": str(desc).lower(),
+        }
+        if status:
+            params["status"] = status
+
+        response = requests.get(
+            f"{self._integrations_url}/{integration_id}/syncs",
+            params=params,
+            headers={"Authorization": "Bearer " + self._api_key},
+        )
+        response.raise_for_status()
+        cursor_page = response.json()
+        return cast(List[Dict], cursor_page.get("data", []))
+
+    def get_latest_sync(self, integration_id: str) -> Optional[Dict]:
+        """
+        Retrieves the most recent sync run for an integration.
+
+        Args:
+            integration_id (str): The ID of the integration.
+
+        Returns:
+            Optional[Dict]: The most recent DAG run, or None if no syncs exist.
+        """
+        syncs = self.get_syncs(integration_id, limit=1, desc=True)
+        return syncs[0] if syncs else None

{definite_sdk-0.1.15 → definite_sdk-0.1.17}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "definite-sdk"
-version = "0.1.15"
+version = "0.1.17"
 description = "Definite SDK for Python"
 authors = ["Definite <hello@definite.app>"]
 license = "MIT"
@@ -9,13 +9,12 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = "^3.9"
 requests = "^2.31.0"
-dlt = {version = "^1.0", optional = true}
-duckdb = {version = "^1.0", optional = true}
+dlt = { version = "^1.0", optional = true }
+duckdb = { version = "^1.0", optional = true }
 
 [tool.poetry.extras]
 dlt = ["dlt", "duckdb"]
 
-
 [tool.poetry.group.dev.dependencies]
 black = "^24.4.2"
 flake8 = "^7.0.0"

definite_sdk-0.1.15/definite_sdk/integration.py

@@ -1,117 +0,0 @@
-from typing import Iterator, Optional, Tuple
-
-import requests
-
-INTEGRATION_ENDPOINT = "/v1/api/integration"
-
-
-class DefiniteIntegrationStore:
-    """
-    Read only access to the integration store on Definite.
-
-    Initialization:
-    >>> client = DefiniteSdkClient("MY_API_KEY")
-    >>> integration_store = client.get_integration_store()
-
-    Accessing values:
-    >>> integration_store.list_integrations()
-    >>> integration_store.get_integration("name")
-    >>> integration_store.get_integration_by_id("integration_id")
-    """
-
-    def __init__(self, api_key: str, api_url: str):
-        """
-        Initializes the DefiniteSecretStore
-
-        Args:
-            api_key (str): The API key for authorization.
-        """
-        self._api_key = api_key
-        self._integration_store_url = api_url + INTEGRATION_ENDPOINT
-
-    def list_integrations(self) -> Iterator[dict]:
-        """
-        Lists all integrations in the store.
-
-        Returns:
-            Iterator[str]: An iterator of integrations.
-        """
-        response = requests.get(
-            self._integration_store_url,
-            headers={"Authorization": "Bearer " + self._api_key},
-        )
-        response.raise_for_status()
-        return iter(response.json())
-
-    def get_integration(self, name: str) -> dict:
-        """
-        Retrieves an integration by name.
-
-        Args:
-            name (str): The name of the integration.
-
-        Returns:
-            str: The value of the integration.
-        """
-        response = requests.get(
-            self._integration_store_url + f"/{name}",
-            headers={"Authorization": "Bearer " + self._api_key},
-        )
-        response.raise_for_status()
-        return dict(response.json())
-
-    def get_integration_by_id(self, integration_id: str) -> dict:
-        """
-        Retrieves an integration by ID.
-
-        Args:
-            integration_id (str): The ID of the integration.
-
-        Returns:
-            dict: The integration details.
-        """
-        response = requests.get(
-            self._integration_store_url + f"/id/{integration_id}",
-            headers={"Authorization": "Bearer " + self._api_key},
-        )
-        response.raise_for_status()
-        return dict(response.json())
-
-    def lookup_duckdb_integration(self) -> Optional[Tuple[str, str]]:
-        """
-        Look up the team's DuckDB integration.
-
-        Note: Currently, the API only returns extractor (source) integrations.
-        Destination integrations like DuckDB are not yet exposed through this endpoint.
-        This method is provided for future compatibility when the API is updated.
-
-        Returns:
-            Optional[Tuple[str, str]]: Tuple of (integration_id, connection_uri)
-                if found, None if no DuckDB integration exists.
-        """
-        try:
-            response = requests.get(
-                self._integration_store_url,
-                headers={"Authorization": "Bearer " + self._api_key},
-            )
-            response.raise_for_status()
-            integrations = response.json()
-        except:
-            return None
-
-        # Check for DuckDB in the integrations
-        # Note: Currently this will not find DuckDB as it's a destination integration
-        for integration in integrations:
-            integration_type = integration.get("integration_type", "").lower()
-            if integration_type == "duckdb" and integration.get("active", True):
-                integration_id = integration.get("id")
-                # Connection URI might be in config or connection_string field
-                connection_uri = (
-                    integration.get("connection_string")
-                    or integration.get("config", {}).get("database_path")
-                    or integration.get("config", {}).get("connection_string")
-                )
-                if integration_id and connection_uri:
-                    return (integration_id, connection_uri)
-
-        return None