dhisana 0.0.1.dev218__tar.gz → 0.0.1.dev220__tar.gz

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/PKG-INFO

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

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/setup.py

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

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/src/dhisana/schemas/sales.py

@@ -1,3 +1,5 @@
+import json
+
 from uuid import UUID
 from pydantic import BaseModel, Field, field_validator
 from typing import List, Optional, Dict, Any
@@ -10,14 +12,20 @@ from typing import Optional, List, Dict, Literal
 # -----------------------------
 
 class Lead(BaseModel):
-    id: Optional[str] = None
+    id: Optional[UUID] = None
     full_name: Optional[str] = None
     first_name: Optional[str] = None
     last_name: Optional[str] = None
     email: Optional[str] = None
     user_linkedin_url: Optional[str] = None
     user_linkedin_salesnav_url: Optional[str] = None
+    organization_linkedin_url: Optional[str] = None
+    organization_linkedin_salesnav_url: Optional[str] = None
+    linkedin_follower_count: Optional[int] = None
     primary_domain_of_organization: Optional[str] = None
+    twitter_handle: Optional[str] = None
+    twitch_handle: Optional[str] = None
+    github_handle: Optional[str] = None
     job_title: Optional[str] = None
     phone: Optional[str] = None
     headline: Optional[str] = None
@@ -25,36 +33,68 @@ class Lead(BaseModel):
     organization_name: Optional[str] = None
     organization_website: Optional[str] = None
     summary_about_lead: Optional[str] = None
+
+    qualification_score: Optional[float] = None
+    qualification_reason: Optional[str] = None
+    revenue: Optional[str] = None
+    company_size: Optional[str] = None
+    industry: Optional[str] = None
+
+    keywords: Optional[Any] = None
+    tags: List[str] = []
+    notes: List[str] = []
+    additional_properties: Optional[Dict[str, Any]] = {}
     workflow_stage: Optional[str] = None
-    assigned_to: Optional[str] = None
-    engaged: Optional[bool] = None
+
+    engaged: bool = False
     last_contact: Optional[int] = None
-    additional_properties: Optional[Dict[str, Any]] = None
     research_summary: Optional[str] = None
-    task_ids: Optional[List[str]] = None
-    email_validation_status: Optional[
-        Literal["not_started", "in_progress", "valid", "invalid"]
-    ] = None
-    linkedin_validation_status: Optional[
-        Literal["not_started", "in_progress", "valid", "invalid"]
-    ] = None
-    research_status: Optional[
-        Literal["not_started", "in_progress", "done", "failed"]
-    ] = None
-    enchrichment_status: Optional[
-        Literal["not_started", "in_progress", "done", "failed"]
-    ] = None
-
-    @field_validator(
-        "linkedin_validation_status",
-        "email_validation_status",
-        "research_status",
-        "enchrichment_status",
-        mode="before"
-    )
+    email_validation_status: Optional[str] = None
+    linkedin_validation_status: Optional[str] = None
+    research_status: Optional[str] = None
+    enchrichment_status: Optional[str] = None
+
+
+    @field_validator("linkedin_follower_count", mode="before")
+    @classmethod
+    def parse_linkedin_follower_count(cls, v):
+        if v is None or v == "":
+            return None
+        if isinstance(v, str):
+            v = v.strip()
+            if v == "":
+                return None
+            try:
+                return int(v)
+            except ValueError:
+                raise ValueError("linkedin_follower_count must be an integer")
+        return v
+
+    @field_validator("notes", mode="before")
     @classmethod
-    def empty_string_to_none(cls, v):
-        return None if v == "" else v
+    def ensure_notes_list(cls, v):
+        """Coerce notes to a list of strings.
+        Handles legacy cases where the DB may contain a scalar or JSON string.
+        """
+        if v is None:
+            return []
+        if isinstance(v, list):
+            # Ensure all elements are strings
+            return [str(item) if not isinstance(item, str) else item for item in v]
+        if isinstance(v, str):
+            # Try to parse JSON array; if not, wrap as single-note list
+            try:
+                parsed = json.loads(v)
+                if isinstance(parsed, list):
+                    return [str(item) if not isinstance(item, str) else item for item in parsed]
+            except Exception:
+                pass
+            return [v]
+        # Fallback: wrap any other scalar/object as a single string entry
+        try:
+            return [json.dumps(v)]
+        except Exception:
+            return [str(v)]
 
 
 class LeadList(BaseModel):

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/src/dhisana/utils/apollo_tools.py

@@ -11,7 +11,7 @@ from dhisana.schemas.sales import LeadsQueryFilters, CompanyQueryFilters
 from dhisana.utils.cache_output_tools import cache_output, retrieve_output
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from urllib.parse import urlparse, parse_qs
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple, Union
 
 from dhisana.utils.clean_properties import cleanup_properties
 
@@ -19,50 +19,81 @@ logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
 
-def get_apollo_access_token(tool_config: Optional[List[Dict]] = None) -> str:
+def get_apollo_access_token(tool_config: Optional[List[Dict]] = None) -> Tuple[str, bool]:
     """
-    Retrieves the APOLLO_API_KEY access token from the provided tool configuration.
+    Retrieves an Apollo access token from tool configuration or environment variables.
 
     Args:
-        tool_config (list): A list of dictionaries containing the tool configuration. 
-                            Each dictionary should have a "name" key and a "configuration" key,
-                            where "configuration" is a list of dictionaries containing "name" and "value" keys.
+        tool_config (list): Optional tool configuration payload provided to the tool.
 
     Returns:
-        str: The APOLLO_API_KEY access token.
+        Tuple[str, bool]: A tuple containing the token string and a boolean flag indicating
+            whether the token represents an OAuth bearer token (``True``) or an API key (``False``).
 
     Raises:
         ValueError: If the Apollo integration has not been configured.
     """
-    APOLLO_API_KEY = None
+    token: Optional[str] = None
+    is_oauth = False
 
     if tool_config:
-        logger.debug(f"Tool config provided: {tool_config}")
         apollo_config = next(
             (item for item in tool_config if item.get("name") == "apollo"), None
         )
         if apollo_config:
             config_map = {
-                item["name"]: item["value"]
+                item["name"]: item.get("value")
                 for item in apollo_config.get("configuration", [])
                 if item
             }
-            APOLLO_API_KEY = config_map.get("apiKey")
+
+            raw_oauth = config_map.get("oauth_tokens")
+            if isinstance(raw_oauth, str):
+                try:
+                    raw_oauth = json.loads(raw_oauth)
+                except Exception:
+                    raw_oauth = None
+            if isinstance(raw_oauth, dict):
+                token = (
+                    raw_oauth.get("access_token")
+                    or raw_oauth.get("token")
+                )
+                if token:
+                    is_oauth = True
+
+            if not token:
+                direct_access_token = config_map.get("access_token")
+                if direct_access_token:
+                    token = direct_access_token
+                    is_oauth = True
+
+            if not token:
+                api_key = config_map.get("apiKey") or config_map.get("api_key")
+                if api_key:
+                    token = api_key
+                    is_oauth = False
         else:
             logger.warning("No 'apollo' config item found in tool_config.")
-    else:
-        logger.debug("No tool_config provided or it's None.")
 
-    # Check environment variable if no key found yet
-    APOLLO_API_KEY = APOLLO_API_KEY or os.getenv("APOLLO_API_KEY")
+    if not token:
+        env_oauth_token = os.getenv("APOLLO_ACCESS_TOKEN")
+        if env_oauth_token:
+            token = env_oauth_token
+            is_oauth = True
+
+    if not token:
+        env_api_key = os.getenv("APOLLO_API_KEY")
+        if env_api_key:
+            token = env_api_key
+            is_oauth = False
 
-    if not APOLLO_API_KEY:
+    if not token:
         logger.error("Apollo integration is not configured.")
         raise ValueError(
             "Apollo integration is not configured. Please configure the connection to Apollo in Integrations."
         )
 
-    return APOLLO_API_KEY
+    return token, is_oauth
 
 
 @assistant_tool
@@ -94,16 +125,17 @@ async def enrich_person_info_from_apollo(
     """
     logger.info("Entering enrich_person_info_from_apollo")
 
-    APOLLO_API_KEY = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
 
     if not linkedin_url and not email and not phone:
         logger.warning("No linkedin_url, email, or phone provided. At least one is required.")
         return {'error': "At least one of linkedin_url, email, or phone must be provided"}
 
-    headers = {
-        "X-Api-Key": f"{APOLLO_API_KEY}",
-        "Content-Type": "application/json"
-    }
+    headers = {"Content-Type": "application/json"}
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     data = {}
     if linkedin_url:
@@ -186,11 +218,12 @@ async def lookup_person_in_apollo_by_name(
         logger.warning("No full_name provided.")
         return {'error': "Full name is required"}
 
-    APOLLO_API_KEY = get_apollo_access_token(tool_config)
-    headers = {
-        "X-Api-Key": f"{APOLLO_API_KEY}",
-        "Content-Type": "application/json"
-    }
+    token, is_oauth = get_apollo_access_token(tool_config)
+    headers = {"Content-Type": "application/json"}
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     # Construct the query payload
     data = {
@@ -263,18 +296,21 @@ async def enrich_organization_info_from_apollo(
     """
     logger.info("Entering enrich_organization_info_from_apollo")
 
-    APOLLO_API_KEY = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
 
     if not organization_domain:
         logger.warning("No organization domain provided.")
         return {'error': "organization domain must be provided"}
 
     headers = {
-        "X-Api-Key": f"{APOLLO_API_KEY}",
         "Content-Type": "application/json",
         "Cache-Control": "no-cache",
         "accept": "application/json"
     }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     cached_response = retrieve_output("enrich_organization_info_from_apollo", organization_domain)
     if cached_response is not None:
@@ -364,12 +400,15 @@ async def search_people_with_apollo(
         logger.warning("No payload given; returning empty result.")
         return []
 
-    api_key = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
     headers = {
         "Cache-Control": "no-cache",
         "Content-Type": "application/json",
-        "X-Api-Key": api_key,
     }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     url = "https://api.apollo.io/api/v1/mixed_people/search"
     logger.info(f"Sending payload to Apollo (single page): {json.dumps(dynamic_payload, indent=2)}")
@@ -840,12 +879,15 @@ async def search_leads_with_apollo_page(
           f" Payload: {json.dumps(page_payload, indent=2)}")
 
     # Get the full Apollo API response with pagination metadata
-    api_key = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
     headers = {
         "Cache-Control": "no-cache",
         "Content-Type": "application/json",
-        "X-Api-Key": api_key,
     }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     url = "https://api.apollo.io/api/v1/mixed_people/search"
     
@@ -950,17 +992,20 @@ async def get_organization_details_from_apollo(
     """
     logger.info("Entering get_organization_details_from_apollo")
 
-    APOLLO_API_KEY = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
     if not organization_id:
         logger.warning("No organization_id provided.")
         return {'error': "Organization ID must be provided"}
 
     headers = {
-        "X-Api-Key": APOLLO_API_KEY,
         "Content-Type": "application/json",
         "Cache-Control": "no-cache",
         "Accept": "application/json"
     }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     cached_response = retrieve_output("get_organization_details_from_apollo", organization_id)
     if cached_response is not None:
@@ -1202,12 +1247,15 @@ async def search_companies_with_apollo(
         logger.warning("No payload given; returning empty result.")
         return []
 
-    api_key = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
     headers = {
         "Cache-Control": "no-cache",
         "Content-Type": "application/json",
-        "X-Api-Key": api_key,
     }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     url = "https://api.apollo.io/api/v1/organizations/search"
     logger.info(f"Sending payload to Apollo organizations endpoint (single page): {json.dumps(dynamic_payload, indent=2)}")
@@ -1508,12 +1556,15 @@ async def search_companies_with_apollo_page(
           f" Payload: {json.dumps(cleaned_payload, indent=2)}")
 
     # Get the full Apollo API response with pagination metadata
-    api_key = get_apollo_access_token(tool_config)
+    token, is_oauth = get_apollo_access_token(tool_config)
     headers = {
         "Cache-Control": "no-cache",
         "Content-Type": "application/json",
-        "X-Api-Key": api_key,
     }
+    if is_oauth:
+        headers["Authorization"] = f"Bearer {token}"
+    else:
+        headers["X-Api-Key"] = token
 
     url = "https://api.apollo.io/api/v1/organizations/search"
     

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/src/dhisana/utils/test_connect.py

@@ -2,6 +2,7 @@ import json
 import logging
 import asyncio
 import os
+from datetime import datetime, timedelta, timezone
 from typing import Awaitable, Callable, Dict, List, Any, Optional
 import requests
 
@@ -420,6 +421,112 @@ async def test_sendgrid(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(e)}
 
 
+async def test_samgov(api_key: str) -> Dict[str, Any]:
+    """Test SAM.gov connectivity by fetching a single opportunity."""
+
+    url = "https://api.sam.gov/opportunities/v2/search"
+    now = datetime.now(timezone.utc)
+    posted_to = now.strftime("%Y-%m-%dT%H:%M:%SZ")
+    posted_from = (now - timedelta(days=7)).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    params = {
+        "limit": 1,
+        "offset": 0,
+        "keyword": "software",
+        "status": "active",
+        "includeCount": "true",
+        "postedFrom": posted_from,
+        "postedTo": posted_to,
+        "api_key": api_key,
+    }
+
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+
+            async def perform(request_params: Dict[str, Any]):
+                async with session.get(url, params=request_params) as response:
+                    status = response.status
+                    body_text = await response.text()
+                    data: Optional[Dict[str, Any]] = None
+
+                    try:
+                        parsed = json.loads(body_text)
+                        if isinstance(parsed, dict):
+                            data = parsed
+                    except json.JSONDecodeError:
+                        data = None
+
+                    return status, data, body_text
+
+            status, data, body_text = await perform(params)
+
+            def extract_error_message(payload: Optional[Dict[str, Any]], fallback_text: str) -> Optional[str]:
+                if not payload:
+                    return fallback_text[:200] if fallback_text else None
+
+                errors = payload.get("errors") or payload.get("error")
+                if isinstance(errors, list):
+                    parts = [
+                        err.get("message") if isinstance(err, dict) else str(err)
+                        for err in errors
+                        if err
+                    ]
+                    return "; ".join(parts) if parts else fallback_text[:200]
+                if isinstance(errors, dict):
+                    return errors.get("message") or str(errors)
+                if errors:
+                    return str(errors)
+
+                for key in ("message", "errorMessage", "detail", "description"):
+                    if key in payload and payload[key]:
+                        return str(payload[key])
+
+                return fallback_text[:200] if fallback_text else None
+
+            error_message = extract_error_message(data, body_text)
+
+            if status == 400 and error_message and "Invalid Date Entered" in error_message:
+                fallback_params = dict(params)
+                fallback_params["postedFrom"] = (now - timedelta(days=7)).strftime("%m/%d/%Y")
+                fallback_params["postedTo"] = now.strftime("%m/%d/%Y")
+                status, data, body_text = await perform(fallback_params)
+                error_message = extract_error_message(data, body_text)
+
+            if status != 200:
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": error_message or f"SAM.gov non-200: {status}",
+                }
+
+            if not data:
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": "SAM.gov returned invalid JSON response.",
+                }
+
+            if data.get("errors"):
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": extract_error_message(data, body_text) or "SAM.gov reported errors.",
+                }
+
+            if data.get("opportunitiesData") or data.get("totalRecords") is not None:
+                return {"success": True, "status_code": status, "error_message": None}
+
+            return {
+                "success": False,
+                "status_code": status,
+                "error_message": "Unexpected SAM.gov response payload.",
+            }
+
+    except Exception as e:
+        logger.error(f"SAM.gov test failed: {e}")
+        return {"success": False, "status_code": 0, "error_message": str(e)}
+
+
 async def test_salesforce(
     username: str,
     password: str,
@@ -1086,8 +1193,9 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "clay":             test_clay,
         "mcpServer":        test_mcp_server,
         "slack":            test_slack,
-        "mailgun":         test_mailgun,
+        "mailgun":          test_mailgun,
         "sendgrid":         test_sendgrid,
+        "samgov":          test_samgov,
     }
 
     results: Dict[str, Dict[str, Any]] = {}

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/src/dhisana.egg-info/PKG-INFO

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

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/tests/test_apollo_company_search.py

@@ -116,7 +116,7 @@ class TestApolloCompanySearch(unittest.TestCase):
     @patch('src.dhisana.utils.apollo_tools.get_apollo_access_token')
     async def test_search_companies_with_apollo_page(self, mock_get_token, mock_fetch_data):
         """Test the paginated company search function."""
-        mock_get_token.return_value = "test_api_key"
+        mock_get_token.return_value = ("test_api_key", False)
         mock_fetch_data.return_value = self.mock_apollo_response
         
         query = CompanyQueryFilters(
@@ -189,7 +189,7 @@ class TestApolloCompanySearch(unittest.TestCase):
     @patch('src.dhisana.utils.apollo_tools.get_apollo_access_token')
     async def test_search_companies_with_apollo_basic(self, mock_get_token, mock_fetch_data):
         """Test the basic company search function."""
-        mock_get_token.return_value = "test_api_key"
+        mock_get_token.return_value = ("test_api_key", False)
         mock_fetch_data.return_value = self.mock_apollo_response
         
         payload = {

{dhisana-0.0.1.dev218 → dhisana-0.0.1.dev220}/tests/test_connectivity.py

@@ -2,7 +2,7 @@ import asyncio
 import unittest
 from unittest.mock import AsyncMock, patch
 
-from src.dhisana.utils.test_connect import test_connectivity
+from src.dhisana.utils.test_connect import test_connectivity as run_test_connectivity
 
 
 class TestConnectivity(unittest.TestCase):
@@ -17,7 +17,7 @@ class TestConnectivity(unittest.TestCase):
                         ]
                     }
                 ]
-                result = await test_connectivity(tool_config)
+                result = await run_test_connectivity(tool_config)
                 self.assertIn('jinaai', result)
                 self.assertTrue(result['jinaai']['success'])
         asyncio.run(runner())
@@ -33,7 +33,7 @@ class TestConnectivity(unittest.TestCase):
                         ]
                     }
                 ]
-                result = await test_connectivity(tool_config)
+                result = await run_test_connectivity(tool_config)
                 self.assertIn('firecrawl', result)
                 self.assertTrue(result['firecrawl']['success'])
         asyncio.run(runner())
@@ -57,11 +57,30 @@ class TestConnectivity(unittest.TestCase):
                         ]
                     }
                 ]
-                result = await test_connectivity(tool_config)
+                result = await run_test_connectivity(tool_config)
                 self.assertIn('salesforce', result)
                 self.assertTrue(result['salesforce']['success'])
         asyncio.run(runner())
 
+    def test_samgov_dispatch(self):
+        async def runner():
+            with patch(
+                'src.dhisana.utils.test_connect.test_samgov',
+                new=AsyncMock(return_value={'success': True, 'status_code': 200, 'error_message': None})
+            ):
+                tool_config = [
+                    {
+                        'name': 'samgov',
+                        'configuration': [
+                            {'name': 'apiKey', 'value': 'dummy'}
+                        ]
+                    }
+                ]
+                result = await run_test_connectivity(tool_config)
+                self.assertIn('samgov', result)
+                self.assertTrue(result['samgov']['success'])
+        asyncio.run(runner())
+
 
 if __name__ == '__main__':
     unittest.main()