dhisana 0.0.1.dev13__tar.gz → 0.0.1.dev14__tar.gz

{dhisana-0.0.1.dev13 → dhisana-0.0.1.dev14}/PKG-INFO

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

{dhisana-0.0.1.dev13 → dhisana-0.0.1.dev14}/setup.py

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

{dhisana-0.0.1.dev13 → dhisana-0.0.1.dev14}/src/dhisana/ui/components.py

@@ -208,24 +208,46 @@ class Upload(Component):
             },
         }
 
-class Button(Component):
-    def __init__(self, label: str, button_type: str = 'button', disabled: bool = False, on_click: Optional[str] = None, style: Optional[Dict[str, Any]] = None):
+class Button:
+    def __init__(
+        self,
+        label: str = '',
+        on_click: str = None,
+        button_type: str = 'button',
+        condition: str = None,
+        confirm: bool = False,
+        confirmMessage: str = '',
+        style: dict = None,
+        icon: str = None,
+        disabled: bool = False,
+        btn_class: str = 'btn btn-secondary',
+    ):
         self.label = label
+        self.on_click = on_click
         self.button_type = button_type
+        self.condition = condition
+        self.confirm = confirm
+        self.confirmMessage = confirmMessage
+        self.style = style or {}
+        self.icon = icon
         self.disabled = disabled
-        self.on_click = on_click
-        self.style = style
+        self.btn_class = btn_class
 
     def to_dict(self):
         return {
             'type': 'button',
             'properties': {
                 'label': self.label,
-                'type': self.button_type,
-                'disabled': self.disabled,
                 'onClick': self.on_click,
+                'buttonType': self.button_type,
+                'condition': self.condition,
+                'confirm': self.confirm,
+                'confirmMessage': self.confirmMessage,
                 'style': self.style,
-            },
+                'icon': self.icon,
+                'disabled': self.disabled,
+                'btnClass': self.btn_class,
+            },            
         }
 
 class Text(Component):

{dhisana-0.0.1.dev13 → dhisana-0.0.1.dev14}/src/dhisana/utils/agent_tools.py

@@ -45,4 +45,7 @@ if 'GLOBAL_TOOLS_FUNCTIONS' not in globals():
 
 # Ensure GLOBAL_OPENAI_ASSISTANT_TOOLS is only initialized once
 if 'GLOBAL_OPENAI_ASSISTANT_TOOLS' not in globals():
-    GLOBAL_OPENAI_ASSISTANT_TOOLS = []
+    GLOBAL_OPENAI_ASSISTANT_TOOLS = []
+    
+if 'GLOBAL_TOOLS_CACHE_PATH' not in globals():
+    GLOBAL_TOOLS_CACHE_PATH = '/tmp/dhisana_ai'

dhisana-0.0.1.dev14/src/dhisana/utils/apollo_tools.py

@@ -0,0 +1,319 @@
+import asyncio
+import hashlib
+import json
+import logging
+import os
+import aiohttp
+import backoff
+from typing import List, Optional
+from datetime import datetime, timedelta
+from dhisana.utils.cache_output import cache_output,retrieve_output
+from dhisana.utils.assistant_tool_tag import assistant_tool
+
+# Assuming cache_output and retrieve_output are defined elsewhere in the file
+# from .cache_utils import cache_output, retrieve_output
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=2,
+    giveup=lambda e: e.status != 429,
+    factor=10,
+)
+async def enrich_person_info_from_apollo(
+    linkedin_url: Optional[str] = None,
+    email: Optional[str] = None,
+    phone: Optional[str] = None,
+):
+    """
+    Fetch a person's details from Apollo using LinkedIn URL, email, or phone number.
+    
+    Parameters:
+    - **linkedin_url** (*str*, optional): LinkedIn profile URL of the person.
+    - **email** (*str*, optional): Email address of the person.
+    - **phone** (*str*, optional): Phone number of the person.
+
+    Returns:
+    - **dict**: JSON response containing person information.
+    """
+    APOLLO_API_KEY = os.environ.get('APOLLO_API_KEY')
+    if not APOLLO_API_KEY:
+        return {'error': "Apollo API key not found in environment variables"}
+
+    if not linkedin_url and not email and not phone:
+        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"
+    }
+
+    data = {}
+    if linkedin_url:
+        data['linkedin_url'] = linkedin_url
+        cached_response = retrieve_output("enrich_person_info_from_apollo", linkedin_url)
+        if cached_response:
+            return cached_response
+    if email:
+        data['email'] = email
+    if phone:
+        data['phone_numbers'] = [phone]  # Apollo expects a list for phone numbers
+
+    url = 'https://api.apollo.io/v1/people/match'
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(url, headers=headers, json=data) as response:
+            if response.status == 200:
+                result = await response.json()
+                if linkedin_url:
+                    cache_output("enrich_person_info_from_apollo", linkedin_url, result)
+                return result
+            elif response.status == 429:
+                logging.warning("enrich_person_info_from_apollo Rate limit hit")
+                await asyncio.sleep(30)
+                raise aiohttp.ClientResponseError(
+                    request_info=response.request_info,
+                    history=response.history,
+                    status=response.status,
+                    message="Rate limit exceeded",
+                    headers=response.headers
+                )
+            else:
+                result = await response.json()
+                logging.warning(f"enrich_person_info_from_apollo Failed to run assistant: ${result}")
+                return {'error': result}
+
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=2,
+    giveup=lambda e: e.status != 429,
+    factor=30,
+)
+async def enrich_company_info_from_apollo(
+    company_domain: Optional[str] = None,
+):
+    """
+    Fetch a company's details from Apollo using the company domain.
+    
+    Parameters:
+    - **company_domain** (*str*, optional): Domain of the company.
+
+    Returns:
+    - **dict**: JSON response containing company information.
+    """
+    APOLLO_API_KEY = os.environ.get('APOLLO_API_KEY')
+    if not APOLLO_API_KEY:
+        return {'error': "Apollo API key not found in environment variables"}
+
+    if not company_domain:
+        return {'error': "Company domain must be provided"}
+
+    headers = {
+        "X-Api-Key": f"{APOLLO_API_KEY}",
+        "Content-Type": "application/json",
+        "Cache-Control": "no-cache",
+        "accept": "application/json"
+    }
+
+    cached_response = retrieve_output("enrich_company_info_from_apollo", company_domain)
+    if cached_response:
+        return cached_response
+
+    url = f'https://api.apollo.io/api/v1/organizations/enrich?domain={company_domain}'
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            if response.status == 200:
+                result = await response.json()
+                cache_output("enrich_company_info_from_apollo", company_domain, result)
+                return result
+            elif response.status == 429:
+                raise aiohttp.ClientResponseError(
+                    request_info=response.request_info,
+                    history=response.history,
+                    status=response.status,
+                    message="Rate limit exceeded",
+                    headers=response.headers
+                )
+            else:
+                result = await response.json()
+                return {'error': result}
+            
+@assistant_tool
+async def get_enriched_customer_information(
+    linkedin_url: Optional[str] = None,
+    email: Optional[str] = None,
+    phone: Optional[str] = None,
+    required_fields: Optional[List[str]] = None,
+    data_sources: Optional[List[str]] = None,
+):
+    """
+    Fetch a person's details from specified data sources using LinkedIn URL, email, or phone number.
+
+    Parameters:
+    - **linkedin_url** (*str*, optional): LinkedIn profile URL of the person.
+    - **email** (*str*, optional): Email address of the person.
+    - **phone** (*str*, optional): Phone number of the person.
+    - **required_fields** (*List[str]*, optional): Properties of the customer to fetch (e.g., 'job_history', 'education_history', 'skills', etc.).
+    - **data_sources** (*List[str]*, optional): Data sources to fetch from (e.g., 'apollo', 'zoominfo', 'websearch', 'linkedin'). Defaults to all sources.
+
+    Returns:
+    - **dict**: JSON response containing person information.
+    """
+    # Set default values if not provided
+    if required_fields is None:
+        required_fields = [
+            'job_history',
+            'education_history',
+            'skills',
+            'headline',
+            'summary',
+            'experiences',
+            'projects',
+            'certifications',
+            'publications',
+            'languages',
+            'volunteer_work',
+        ]
+    if data_sources is None:
+        data_sources = ['apollo', 'zoominfo', 'websearch', 'linkedin']
+        
+    data = await enrich_person_info_from_apollo(
+                linkedin_url=linkedin_url,
+                email=email,
+                phone=phone,
+            )
+    return data
+
+@assistant_tool
+async def get_enriched_company_information(
+    company_domain: Optional[str] = None,
+    required_fields: Optional[List[str]] = None,
+    data_sources: Optional[List[str]] = None,
+):
+    """
+    Fetch a company's details from specified data sources using the company domain.
+    
+    Parameters:
+    - **company_domain** (*str*, optional): Domain of the company.
+    - **required_fields** (*List[str]*, optional): Properties of the company to fetch (e.g., 'technographics', 'firmographics', 'employee_count', etc.).
+    - **data_sources** (*List[str]*, optional): Data sources to fetch from (e.g., 'apollo', 'zoominfo', 'builtwith', 'linkedin'). Defaults to all sources.
+
+    Returns:
+    - **dict**: JSON response containing company information.
+    """
+    return await enrich_company_info_from_apollo(company_domain=company_domain)
+
+
+
+# Define the backoff strategy for handling rate limiting
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=5,
+    giveup=lambda e: e.status != 429,
+    factor=2,
+)
+async def fetch_apollo_data(session, url, headers, payload):
+    key_data = f"{url}_{json.dumps(payload, sort_keys=True)}"
+    key_hash = hashlib.sha256(key_data.encode()).hexdigest()
+    cached_response = retrieve_output("fetch_apollo_data", key_hash)
+    if cached_response:
+        return cached_response
+
+    async with session.post(url, headers=headers, json=payload) as response:
+        if response.status == 200:
+            result = await response.json()
+            cache_output("fetch_apollo_data", key_hash, result)
+            return result
+        elif response.status == 429:
+            raise aiohttp.ClientResponseError(
+                request_info=response.request_info,
+                history=response.history,
+                status=response.status,
+                message="Rate limit exceeded",
+                headers=response.headers
+            )
+        else:
+            response.raise_for_status()
+
+@assistant_tool
+async def search_recent_job_changes(
+    job_titles: List[str],
+    locations: List[str],
+    organization_num_employees_ranges: Optional[List[str]] = None,
+    items_to_return: int = 100
+) -> List[dict]:
+    """
+    Search for individuals with specified job titles, locations, and optionally organization employee ranges who have recently changed jobs using searchSignalIds.
+
+    Parameters:
+    - **job_titles** (*List[str]*): List of job titles to search for.
+    - **locations** (*List[str]*): List of locations to search in.
+    - **organization_num_employees_ranges** (*Optional[List[str]]*, optional): List of employee ranges to filter organizations by (e.g., ["1,10", "11,50"]). Defaults to None.
+    - **items_to_return** (*int*, optional): Total number of items to return. Defaults to 100.
+
+    Returns:
+    - **List[dict]**: List of individuals matching the criteria or error details.
+    """
+    APOLLO_API_KEY = os.getenv('APOLLO_API_KEY')
+    if not APOLLO_API_KEY:
+        raise EnvironmentError("Apollo API key not found in environment variables")
+
+    headers = {
+        "Cache-Control": "no-cache",
+        "Content-Type": "application/json",
+        "X-Api-Key": f"{APOLLO_API_KEY}",
+    }
+
+    url = 'https://api.apollo.io/v1/mixed_people/search'
+
+    # Define the search signal ID for recent job changes (e.g., "Job Change (90 Days)")
+    search_signal_ids = ["643daa349293c1cdaa4d00f8"]
+
+    # Initialize the session
+    async with aiohttp.ClientSession() as session:
+        results = []
+        page = 1
+        per_page = min(items_to_return, 100)  # Apollo API allows a maximum of 100 items per page
+
+        while len(results) < items_to_return:
+            payload = {
+                "person_titles": job_titles,
+                "person_locations": locations,
+                "search_signal_ids": search_signal_ids,
+                "page": page,
+                "per_page": per_page
+            }
+
+            if organization_num_employees_ranges:
+                payload["organization_num_employees_ranges"] = organization_num_employees_ranges
+
+            try:
+                data = await fetch_apollo_data(session, url, headers, payload)
+                people = data.get('people', [])
+                if not people:
+                    break
+                results.extend(people)
+                if len(people) < per_page:
+                    break
+                page += 1
+            except aiohttp.ClientResponseError as e:
+                if e.status == 429:
+                    await asyncio.sleep(30)  # Wait before retrying
+                else:
+                    # Return error details as JSON string in an array
+                    error_details = {
+                        'status': e.status,
+                        'message': str(e),
+                        'url': str(e.request_info.url),
+                        'headers': dict(e.headers),
+                    }
+                    error_json = json.dumps(error_details)
+                    return [error_json]
+
+        return results[:items_to_return]

dhisana-0.0.1.dev14/src/dhisana/utils/built_with_api_tools.py

@@ -0,0 +1,129 @@
+import os
+import aiohttp
+from typing import Optional
+import os
+import aiohttp
+import backoff
+from dhisana.utils.cache_output import cache_output,retrieve_output
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from typing import Optional
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=2,
+    giveup=lambda e: e.status != 429,
+    factor=10,
+)
+async def get_company_info_from_builtwith(
+    company_domain: Optional[str] = None,
+):
+    """
+    Fetch a company's technology details from BuiltWith using the company domain.
+    
+    Parameters:
+    - **company_domain** (*str*, optional): Domain of the company.
+
+    Returns:
+    - **dict**: JSON response containing technology information.
+    """
+    BUILTWITH_API_KEY = os.environ.get('BUILTWITH_API_KEY')
+    if not BUILTWITH_API_KEY:
+        return {'error': "BuiltWith API key not found in environment variables"}
+
+    if not company_domain:
+        return {'error': "Company domain must be provided"}
+
+    headers = {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-cache",
+        "accept": "application/json"
+    }
+
+    cached_response = retrieve_output("get_company_info_from_builtwith", company_domain)  # Replace with your caching logic if needed
+    if cached_response:
+        return cached_response
+
+    url = f'https://api.builtwith.com/v19/api.json?KEY={BUILTWITH_API_KEY}&LOOKUP={company_domain}'
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            if response.status == 200:
+                result = await response.json()
+                cache_output("get_company_info_from_builtwith", company_domain, result)  # Replace with your caching logic if needed
+                return result
+            elif response.status == 429:
+                raise aiohttp.ClientResponseError(
+                    request_info=response.request_info,
+                    history=response.history,
+                    status=response.status,
+                    message="Rate limit exceeded",
+                    headers=response.headers
+                )
+            else:
+                try:
+                    result = await response.json()
+                    return {'error': result}
+                except Exception as e:
+                    return {'error': f"Unexpected error: {str(e)}"}
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=2,
+    giveup=lambda e: e.status != 429,
+    factor=10,
+)
+async def get_company_financials_from_builtwith(
+    company_domain: Optional[str] = None,
+):
+    """
+    Fetch a company's financial details from BuiltWith using the company domain.
+    
+    Parameters:
+    - **company_domain** (*str*, optional): Domain of the company.
+
+    Returns:
+    - **dict**: JSON response containing financial information.
+    """
+    BUILTWITH_API_KEY = os.environ.get('BUILTWITH_API_KEY')
+    if not BUILTWITH_API_KEY:
+        return {'error': "BuiltWith API key not found in environment variables"}
+
+    if not company_domain:
+        return {'error': "Company domain must be provided"}
+
+    headers = {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-cache",
+        "accept": "application/json"
+    }
+
+    cached_response = retrieve_output("get_company_financials_from_builtwith", company_domain)  # Replace with your caching logic if needed
+    if cached_response:
+        return cached_response
+
+    url = f'https://api.builtwith.com/v19/financial.json?KEY={BUILTWITH_API_KEY}&LOOKUP={company_domain}'
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            if response.status == 200:
+                result = await response.json()
+                cache_output("get_company_financials_from_builtwith", company_domain, result)  # Replace with your caching logic if needed
+                return result
+            elif response.status == 429:
+                raise aiohttp.ClientResponseError(
+                    request_info=response.request_info,
+                    history=response.history,
+                    status=response.status,
+                    message="Rate limit exceeded",
+                    headers=response.headers
+                )
+            else:
+                try:
+                    result = await response.json()
+                    return {'error': result}
+                except Exception as e:
+                    return {'error': f"Unexpected error: {str(e)}"}

dhisana-0.0.1.dev14/src/dhisana/utils/cache_output.py

@@ -0,0 +1,70 @@
+import os
+import hashlib
+import json
+
+CACHE_PATH = '/tmp/dhisana_ai/cache_run_outputs/'
+
+def cache_output(tool_name, key, value, ttl=None):
+    """
+    Cache the output of a function using the provided key and value.
+
+    Parameters:
+    tool_name (str): Name of the tool whose output is being cached.
+    key (str): The cache key.
+    value (Any): The value to be cached.
+    ttl (int, optional): The time-to-live (TTL) for the cached value in seconds.
+
+    Returns:
+    bool: True if the value was successfully cached, False otherwise.
+    """
+    # Ensure the cache directory exists
+    if not os.path.exists(CACHE_PATH):
+        os.makedirs(CACHE_PATH)
+
+    # Create a hash of the key
+    key_hash = hashlib.sha256(key.encode()).hexdigest()
+
+    # Create the cache file path
+    cache_file_path = os.path.join(CACHE_PATH, f"{tool_name}_{key_hash}.json")
+
+    # Create the cache data
+    cache_data = {
+        'value': value,
+        'ttl': ttl
+    }
+
+    # Write the cache data to the file
+    try:
+        with open(cache_file_path, 'w') as cache_file:
+            json.dump(cache_data, cache_file)
+        return True
+    except IOError:
+        return False
+
+def retrieve_output(tool_name, key):
+    """
+    Retrieve the cached output for a given tool and cache key.
+
+    Parameters:
+    tool_name (str): Name of the tool whose output is being retrieved.
+    key (str): The cache key.
+
+    Returns:
+    Any: The cached value if found, None otherwise.
+    """
+    # Create a hash of the key
+    key_hash = hashlib.sha256(key.encode()).hexdigest()
+
+    # Create the cache file path
+    cache_file_path = os.path.join(CACHE_PATH, f"{tool_name}{key_hash}.json")
+
+    # Read the cache data from the file
+    if os.path.exists(cache_file_path):
+        try:
+            with open(cache_file_path, 'r') as cache_file:
+                cache_data = json.load(cache_file)
+                return cache_data['value']
+        except IOError:
+            return None
+    else:
+        return None

dhisana-0.0.1.dev14/src/dhisana/utils/composite_tools.py

@@ -0,0 +1,88 @@
+import json
+from pydantic import BaseModel, Field
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from dhisana.utils.built_with_api_tools import get_company_info_from_builtwith
+from dhisana.utils.dataframe_tools import get_structured_output
+from dhisana.utils.serpapi_search_tools import search_google
+
+class QualifyCompanyBasedOnTechUsage(BaseModel):
+    company_name: str = Field(..., description="Name of the company")
+    is_company_qualified: str = Field(..., description="True if the company satifises qualification criteria in input. False otherwise.")
+    reason_for_qualification: str = Field(..., description="Reason for qualification")
+    
+     
+@assistant_tool
+async def find_tech_usage_in_company(
+    company_domain: str,
+    company_name: str,
+    technology_to_look_for: str
+):
+    """
+    Determine if a company is using a specific technology.
+
+    Args:
+        company_domain (str): The domain name of the company's website.
+        company_name (str): The name of the company.
+        technology_to_look_for (str): The technology to look for.
+
+    Returns:
+        str: A JSON string containing the structured output.
+    """
+    # Search for job postings on the company's website mentioning the technology
+    company_domain_search = f"site:{company_domain} {company_name} jobs or careers having {technology_to_look_for}"
+    search_google_results = await search_google(company_domain_search, 2)
+
+    # Search LinkedIn for people at the company with skills in the technology
+    linked_in_search = f"site:linkedin.com/in OR site:linkedin.com/jobs {company_name} having people with {technology_to_look_for} skills"
+    people_with_skills_results = await search_google(linked_in_search, 2)
+
+    # Get technologies used by the company from BuiltWith
+    data = await get_company_info_from_builtwith(company_domain)
+    technologies = get_technologies(data)
+    tech_found_in_builtwith = any(
+        tech.lower() == technology_to_look_for.lower() for tech in technologies
+    )
+
+    # Prepare the prompt for structured output
+    prompt = f"""
+        Mark the company as qualified in is_company_qualified if the company {company_name} is using technology {technology_to_look_for}.
+        DO NOT make up information.
+        Give reasoning why company is qualified based on one of the reasons:
+        1. There is a job posting on the company website.
+        2. There are people with that skill in the company.
+        3. BuiltWith shows the company uses the tech.
+
+        Google search on company careers:
+        {search_google_results}
+
+        Google search on LinkedIn for people with skills:
+        {people_with_skills_results}
+
+        BuiltWith shows technology used: {tech_found_in_builtwith}
+    """
+
+    # Get structured output based on the prompt
+    output, _ = await get_structured_output(prompt, QualifyCompanyBasedOnTechUsage)
+    return json.dumps(output.dict())
+
+def get_technologies(data):
+    """
+    Extract the list of technologies from BuiltWith data.
+
+    Args:
+        data (dict): The data returned by BuiltWith API.
+
+    Returns:
+        List[str]: A list of technology names used by the company.
+    """
+    technologies = []
+    results = data.get('Results', [])
+    if results:
+        paths = results[0].get('Result', {}).get('Paths', [])
+        if paths:
+            techs = paths[0].get('Technologies', [])
+            for tech in techs:
+                tech_name = tech.get('Name', '')
+                if tech_name:
+                    technologies.append(tech_name)
+    return technologies