dhisana 0.0.1.dev243__py3-none-any.whl

dhisana/utils/assistant_tool_tag.py

@@ -0,0 +1,4 @@
+# Read API keys from environment variables
+def assistant_tool(func):
+    func.is_assistant_tool = True
+    return func

dhisana/utils/built_with_api_tools.py

@@ -0,0 +1,282 @@
+import json
+import os
+import aiohttp
+from typing import Optional
+import os
+import aiohttp
+import backoff
+from dhisana.utils.cache_output_tools import cache_output,retrieve_output
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from typing import Optional
+from typing import Optional, List, Dict
+
+def get_builtwith_api_key(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieves the BUILTWITH_API_KEY access token from the provided tool configuration.
+
+    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.
+
+    Returns:
+        str: The BUILTWITH_API_KEY access token.
+
+    Raises:
+        ValueError: If the BuiltWith integration has not been configured.
+    """
+    if tool_config:
+        builtwith_config = next(
+            (item for item in tool_config if item.get("name") == "builtwith"), None
+        )
+        if builtwith_config:
+            config_map = {
+                item["name"]: item["value"]
+                for item in builtwith_config.get("configuration", [])
+                if item
+            }
+            BUILTWITH_API_KEY = config_map.get("apiKey")
+        else:
+            BUILTWITH_API_KEY = None
+    else:
+        BUILTWITH_API_KEY = None
+
+    BUILTWITH_API_KEY = BUILTWITH_API_KEY or os.getenv("BUILTWITH_API_KEY")
+    if not BUILTWITH_API_KEY:
+        raise ValueError(
+            "BuiltWith integration is not configured. Please configure the connection to BuiltWith in Integrations."
+        )
+    return BUILTWITH_API_KEY
+
+# Use BuiltWith API to find tech stack and financials of a company
+@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,
+    tool_config: Optional[List[Dict]] = 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 = get_builtwith_api_key(tool_config=tool_config)
+
+    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 is not None:
+        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,
+    tool_config: Optional[List[Dict]] = 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 = get_builtwith_api_key(tool_config=tool_config)
+
+    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 is not None:
+        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)}"}
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=3,
+    giveup=lambda e: e.status != 429,
+    factor=10,
+)
+async def get_company_info_from_builtwith_by_name(company_name: str, tool_config: Optional[List[Dict]] = None):
+    """
+    Fetch a company's technology details from BuiltWith using the company name.
+
+    Parameters:
+    - company_name (str): Name of the company.
+
+    Returns:
+    - dict: JSON response containing technology information or error details.
+    """
+    BUILTWITH_API_KEY = get_builtwith_api_key(tool_config=tool_config)
+
+    if not company_name:
+        return {'error': "Company name must be provided"}
+
+    headers = {
+        "Content-Type": "application/json",
+        "Cache-Control": "no-cache",
+        "Accept": "application/json"
+    }
+
+    # Step 1: Use Company To URL API to get the company's domain
+    company_to_url_api = f'https://ctu.builtwith.com/ctu2/api.json?KEY={BUILTWITH_API_KEY}&COMPANY={company_name}'
+    company_info = retrieve_output("get_company_info_from_builtwith_by_name", company_name)  
+    if company_info:
+        company_domain = company_info.get('Domain')
+        return await get_company_info_from_builtwith(company_domain)
+
+    async with aiohttp.ClientSession() as session:
+        async with session.get(company_to_url_api, headers=headers) as response:
+            if response.status == 200:
+                company_data = await response.json()
+                if isinstance(company_data, list) and company_data:
+                    company_info = company_data[0]
+                    company_domain = company_info.get('Domain')
+                    if not company_domain:
+                        return {'error': "Domain not found for the given company name"}
+                    cache_output("get_company_info_from_builtwith_by_name", company_name, company_info)
+                    return await get_company_info_from_builtwith(company_domain)
+                else:
+                    return {'error': "No results found for the given company name"}
+            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:
+                    error_data = await response.json()
+                    return {'error': error_data}
+                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 is_tech_used_in_company(
+    company_domain: Optional[str] = None, 
+    company_name: Optional[str] = None, 
+    keyword: Optional[str] = None,
+    tool_config: Optional[List[Dict]] = None
+) -> bool:
+    if not company_domain and not company_name:
+        return False
+
+    if not keyword:
+        return False
+
+    if company_domain:
+        company_data_buildwith = await get_company_info_from_builtwith(company_domain, tool_config=tool_config)
+    elif company_name:
+        company_data_buildwith = await get_company_info_from_builtwith_by_name(company_name, tool_config=tool_config)
+        company_domain = company_data_buildwith.get('Lookup', '')
+
+    data_str = json.dumps(company_data_buildwith).lower()
+    keyword_lower = keyword.lower()
+    return keyword_lower in data_str
+
+@assistant_tool
+@backoff.on_exception(
+    backoff.expo,
+    aiohttp.ClientResponseError,
+    max_tries=2,
+    giveup=lambda e: e.status != 429,
+    factor=10,
+)
+async def get_company_domain_from_name(
+    company_name: Optional[str] = None,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    if not company_name:
+        return ''
+
+    company_data_buildwith = await get_company_info_from_builtwith_by_name(company_name, tool_config=tool_config)
+    company_domain = company_data_buildwith.get('Lookup', '')
+    return company_domain
+

dhisana/utils/cache_output_tools.py

@@ -0,0 +1,98 @@
+import os
+import hashlib
+import json
+import logging
+
+from azure.storage.blob import BlobServiceClient
+from azure.core.exceptions import ResourceNotFoundError, AzureError
+
+logger = logging.getLogger(__name__)
+logging.getLogger("azure").setLevel(logging.CRITICAL)
+
+CONTAINER_NAME = "cacheoutputs"
+
+def _get_container_client():
+    """
+    Returns the container client for the cache container.
+    Ensures that the container is created if it doesn't exist.
+    """
+    connection_string = os.environ.get("AZURE_BLOB_CONNECTION_STRING")
+    if not connection_string:
+        raise ValueError("AZURE_BLOB_CONNECTION_STRING environment variable is not set")
+
+    blob_service_client = BlobServiceClient.from_connection_string(connection_string)
+    container_client = blob_service_client.get_container_client(CONTAINER_NAME)
+
+    # Ensure the container exists; if already created, the AzureError is ignored.
+    try:
+        container_client.create_container()
+    except AzureError:
+        pass
+
+    return container_client
+
+def cache_output(tool_name: str, key: str, value, ttl: int = None) -> bool:
+    """
+    Cache the output of a function using Azure Blob Storage.
+
+    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.
+    """
+    # Create a hash of the key for a consistent blob name
+    key_hash = hashlib.sha256(key.encode()).hexdigest()
+    # Construct the blob name using a virtual folder for the tool name
+    blob_name = f"{tool_name}/{key_hash}.json"
+
+    # Prepare the cache data
+    cache_data = {
+        "value": value,
+        "ttl": ttl
+    }
+    data = json.dumps(cache_data)
+
+    try:
+        container_client = _get_container_client()
+        blob_client = container_client.get_blob_client(blob=blob_name)
+        # Upload the blob content (overwrite if the blob already exists)
+        blob_client.upload_blob(data, overwrite=True)
+        return True
+    except Exception as e:
+        logger.error(f"Error uploading blob '{blob_name}': {e}")
+        return False
+
+def retrieve_output(tool_name: str, key: str):
+    """
+    Retrieve the cached output for a given tool and cache key from Azure Blob Storage.
+
+    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 to locate the blob
+    key_hash = hashlib.sha256(key.encode()).hexdigest()
+    # Construct the blob name using the tool name folder
+    blob_name = f"{tool_name}/{key_hash}.json"
+
+    try:
+        container_client = _get_container_client()
+        blob_client = container_client.get_blob_client(blob=blob_name)
+        download_stream = blob_client.download_blob()
+        content = download_stream.readall()  # content is in bytes
+        cache_data = json.loads(content.decode("utf-8"))
+        return cache_data.get("value")
+    except ResourceNotFoundError:
+        # Blob does not exist
+        logger.info(f"Blob '{blob_name}' not found.")
+        return None
+    except Exception as e:
+        logger.error(f"Error retrieving blob '{blob_name}': {e}")
+        return None

dhisana/utils/cache_output_tools_local.py

@@ -0,0 +1,78 @@
+import os
+import hashlib
+import json
+import logging
+
+CACHE_PATH = os.environ.get('AGENT_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:
+        os.makedirs(os.path.dirname(cache_file_path), exist_ok=True)
+        with open(cache_file_path, 'w') as cache_file:
+            json.dump(cache_data, cache_file)
+        return True
+    except IOError as e:
+        logging.error(f"IOError while writing to cache file {cache_file_path}: {e}")
+        return False
+    except Exception as e:
+        logging.error(f"Unexpected error while writing to cache file {cache_file_path}: {e}")
+        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 as e:
+            logging.error(f"Error retrieving cache for tool '{tool_name}' with key '{key}': {e}")
+            return None
+    else:
+        return None