dhisana 0.0.1.dev233__tar.gz → 0.0.1.dev234__tar.gz

{dhisana-0.0.1.dev233 → dhisana-0.0.1.dev234}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev233
+Version: 0.0.1.dev234
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin

{dhisana-0.0.1.dev233 → dhisana-0.0.1.dev234}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name='dhisana',  
-    version='0.0.1-dev233',
+    version='0.0.1-dev234',
     description='A Python SDK for Dhisana AI Platform',
     author='Admin',
     author_email='contact@dhisana.ai',

{dhisana-0.0.1.dev233 → dhisana-0.0.1.dev234}/src/dhisana/utils/test_connect.py

@@ -1263,6 +1263,41 @@ async def test_firecrawl(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(exc)}
 
 
+async def test_scraperapi(api_key: str) -> Dict[str, Any]:
+    """Connectivity check for ScraperAPI using a simple NYTimes scrape."""
+    url = "https://api.scraperapi.com/"
+    params = {
+        "api_key": api_key,
+        "url": "https://example.com/",  # lightweight public page to minimize credit usage
+        "output_format": "markdown",
+    }
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, params=params) as response:
+                status = response.status
+                body_text = await response.text()
+
+                if status != 200:
+                    snippet = body_text[:200] if body_text else None
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": snippet or f"Non-200 from ScraperAPI: {status}",
+                    }
+
+                if not body_text:
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": "ScraperAPI returned an empty response.",
+                    }
+
+                return {"success": True, "status_code": status, "error_message": None}
+    except Exception as exc:
+        logger.error(f"ScraperAPI connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
 async def test_youtube(api_key: str) -> Dict[str, Any]:
     """
     Tests YouTube Data API v3 by making a simple search request.
@@ -1341,6 +1376,276 @@ async def test_youtube(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(exc)}
 
 
+async def test_orum(api_key: str) -> Dict[str, Any]:
+    """
+    Validate an Orum API key by calling a lightweight authenticated endpoint.
+
+    The base URL can be overridden with ORUM_API_BASE_URL if needed.
+    """
+    base_url = os.getenv("ORUM_API_BASE_URL", "https://api.orum.com")
+    url = f"{base_url.rstrip('/')}/api/v1/users/me"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Orum responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Orum connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_aircall(app_id: str, api_token: str) -> Dict[str, Any]:
+    """
+    Validate Aircall credentials via a lightweight authenticated call.
+    Uses HTTP Basic Auth (app_id:api_token).
+    """
+    url = "https://api.aircall.io/v1/users"
+    params = {"per_page": 1}
+
+    try:
+        auth = aiohttp.BasicAuth(app_id, api_token)
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10), auth=auth) as session:
+            async with session.get(url, params=params) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200 and isinstance(data, dict) and "users" in data:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Aircall responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Aircall connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_ringover(api_key: str) -> Dict[str, Any]:
+    """
+    Validate Ringover API key using a minimal authenticated request.
+    """
+    base_url = os.getenv("RINGOVER_API_BASE_URL", "https://public-api.ringover.com")
+    url = f"{base_url.rstrip('/')}/v2/users"
+    headers = {
+        "X-API-KEY": api_key,
+        "Accept": "application/json",
+    }
+    params = {"limit": 1}
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers, params=params) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Ringover responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Ringover connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_dialpad(client_id: str, client_secret: str) -> Dict[str, Any]:
+    """
+    Validate Dialpad client credentials via client_credentials token exchange, then whoami.
+    """
+    base_url = os.getenv("DIALPAD_API_BASE_URL", "https://dialpad.com")
+    token_url = f"{base_url.rstrip('/')}/oauth/token"
+    whoami_url = f"{base_url.rstrip('/')}/api/v2/whoami"
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            token_resp = await session.post(
+                token_url,
+                data={
+                    "grant_type": "client_credentials",
+                    "client_id": client_id,
+                    "client_secret": client_secret,
+                },
+                headers={"Accept": "application/json"},
+            )
+            token_status = token_resp.status
+            token_data = await safe_json(token_resp)
+
+            access_token = None
+            if isinstance(token_data, dict):
+                access_token = token_data.get("access_token")
+
+            if token_status != 200 or not access_token:
+                message = None
+                if isinstance(token_data, dict):
+                    message = token_data.get("error_description") or token_data.get("error")
+                return {
+                    "success": False,
+                    "status_code": token_status,
+                    "error_message": message or "Failed to obtain Dialpad access token.",
+                }
+
+            headers = {
+                "Authorization": f"Bearer {access_token}",
+                "Accept": "application/json",
+            }
+            async with session.get(whoami_url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Dialpad responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Dialpad connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_nooks(api_key: str) -> Dict[str, Any]:
+    """
+    Validate Nooks.ai API key via a simple authenticated call.
+    """
+    base_url = os.getenv("NOOKS_API_BASE_URL", "https://api.nooks.ai")
+    url = f"{base_url.rstrip('/')}/v1/users/me"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = data.get("message") or data.get("error") or data.get("detail")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Nooks.ai responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Nooks.ai connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_commonroom(api_key: str) -> Dict[str, Any]:
+    """Validate a Common Room API token via the token status endpoint."""
+    url = "https://api.commonroom.io/community/v1/api-token-status"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Accept": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status == 200:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                message = None
+                if isinstance(data, dict):
+                    message = (
+                        data.get("message")
+                        or data.get("reason")
+                        or data.get("error")
+                        or data.get("docs")
+                    )
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": message or f"Common Room responded with {status}",
+                }
+    except Exception as exc:
+        logger.error(f"Common Room connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
+async def test_scarf(api_key: str) -> Dict[str, Any]:
+    """
+    Validate a Scarf API token via the lightweight /v2/search endpoint.
+
+    The endpoint requires only the bearer token and a simple query string.
+    """
+    url = "https://api.scarf.sh/v2/search"
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+    payload = {"query": "dhisana connectivity test"}
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.post(url, headers=headers, json=payload) as response:
+                status = response.status
+                data = await safe_json(response)
+
+                if status != 200:
+                    message = None
+                    if isinstance(data, dict):
+                        message = data.get("message") or data.get("error") or data.get("detail")
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": message or f"Scarf responded with {status}",
+                    }
+
+                if isinstance(data, dict) and "results" in data:
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": "Unexpected Scarf response payload.",
+                }
+    except Exception as exc:
+        logger.error(f"Scarf connectivity test failed: {exc}")
+        return {"success": False, "status_code": 0, "error_message": str(exc)}
+
+
 ###############################################################################
 #                              DATAGMA CONNECTIVITY
 ###############################################################################
@@ -1427,6 +1732,13 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "firefliesai":      test_firefliesai,
         "firecrawl":        test_firecrawl,
         "youtube":          test_youtube,
+        "orum":             test_orum,
+        "aircall":          test_aircall,   # handled specially to pass appId + apiToken
+        "ringover":         test_ringover,
+        "dialpad":          test_dialpad,   # handled specially to pass client credentials
+        "nooks":            test_nooks,
+        "commonRoom":       test_commonroom,
+        "scarf":            test_scarf,
         "salesforce":       test_salesforce,
         "clay":             test_clay,
         "posthog":          test_posthog,
@@ -1435,6 +1747,7 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "mailgun":          test_mailgun,
         "sendgrid":         test_sendgrid,
         "samgov":          test_samgov,
+        "scraperapi":       test_scraperapi,
     }
 
     results: Dict[str, Dict[str, Any]] = {}
@@ -1603,6 +1916,40 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
                 )
             continue
 
+        # ------------------------------------------------------------------ #
+        # Special-case: Aircall (app_id + api_token)
+        # ------------------------------------------------------------------ #
+        if tool_name == "aircall":
+            app_id = next((c["value"] for c in config_entries if c["name"] == "apiId"), None)
+            api_token = next((c["value"] for c in config_entries if c["name"] == "apiToken"), None)
+            if not app_id or not api_token:
+                results[tool_name] = {
+                    "success": False,
+                    "status_code": 0,
+                    "error_message": "Missing apiId or apiToken for Aircall.",
+                }
+            else:
+                logger.info("Testing connectivity for Aircall…")
+                results[tool_name] = await test_aircall(app_id, api_token)
+            continue
+
+        # ------------------------------------------------------------------ #
+        # Special-case: Dialpad (client credentials)
+        # ------------------------------------------------------------------ #
+        if tool_name == "dialpad":
+            client_id = next((c["value"] for c in config_entries if c["name"] == "clientId"), None)
+            client_secret = next((c["value"] for c in config_entries if c["name"] == "clientSecret"), None)
+            if not client_id or not client_secret:
+                results[tool_name] = {
+                    "success": False,
+                    "status_code": 0,
+                    "error_message": "Missing clientId or clientSecret for Dialpad.",
+                }
+            else:
+                logger.info("Testing connectivity for Dialpad…")
+                results[tool_name] = await test_dialpad(client_id, client_secret)
+            continue
+
         # ------------------------------------------------------------------ #
         # All other tools – expect an apiKey by default
         # ------------------------------------------------------------------ #

{dhisana-0.0.1.dev233 → dhisana-0.0.1.dev234}/src/dhisana.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dhisana
-Version: 0.0.1.dev233
+Version: 0.0.1.dev234
 Summary: A Python SDK for Dhisana AI Platform
 Home-page: https://github.com/dhisana-ai/dhisana-python-sdk
 Author: Admin