dhisana 0.0.1.dev85__py3-none-any.whl → 0.0.1.dev236__py3-none-any.whl

dhisana/utils/sendgrid_tools.py

@@ -1,117 +1,152 @@
+"""Mail delivery helpers for SendGrid and compatibility exports for Mailgun.
+
+This module now contains:
+- SendGrid: helpers to send e-mail via SendGrid's REST API.
+- Mailgun: re-exports for helpers that were moved to `mailgun_tools.py`.
+"""
+
 import logging
 import os
 from typing import Optional, List, Dict
+from email.utils import parseaddr
+
 import aiohttp
-from dhisana.utils.assistant_tool_tag import assistant_tool
 
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from dhisana.schemas.common import SendEmailContext
+from dhisana.utils.email_body_utils import body_variants
 
-def get_mailgun_notify_key(tool_config: Optional[List[Dict]] = None) -> str:
-    """
-    Retrieves the MAILGUN_NOTIFY_KEY access token from the provided tool configuration.
+# --------------------------------------------------------------------------- #
+# Mailgun (re-exported from dedicated module for backward compatibility)
+# --------------------------------------------------------------------------- #
+from .mailgun_tools import (
+    get_mailgun_notify_key,
+    get_mailgun_notify_domain,
+    send_email_with_mailgun,
+)
 
-    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 MAILGUN_NOTIFY_KEY access token.
+# --------------------------------------------------------------------------- #
+# SendGrid helpers
+# --------------------------------------------------------------------------- #
 
-    Raises:
-        ValueError: If the access token is not found in the tool configuration or environment variable.
+def get_sendgrid_api_key(tool_config: Optional[List[Dict]] = None) -> str:
     """
-    if tool_config:
-        mailgun_config = next(
-            (item for item in tool_config if item.get("name") == "mailgun"), None
-        )
-        if mailgun_config:
-            config_map = {
-                item["name"]: item["value"]
-                for item in mailgun_config.get("configuration", [])
-                if item
-            }
-            MAILGUN_NOTIFY_KEY = config_map.get("apiKey")
-        else:
-            MAILGUN_NOTIFY_KEY = None
-    else:
-        MAILGUN_NOTIFY_KEY = None
-
-    MAILGUN_NOTIFY_KEY = MAILGUN_NOTIFY_KEY or os.getenv("MAILGUN_NOTIFY_KEY")
-    if not MAILGUN_NOTIFY_KEY:
-        raise ValueError("MAILGUN_NOTIFY_KEY access token not found in tool_config or environment variable")
-    return MAILGUN_NOTIFY_KEY
-
-def get_mailgun_notify_domain(tool_config: Optional[List[Dict]] = None) -> str:
-    """
-    Retrieves the MAILGUN_NOTIFY_DOMAIN 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 MAILGUN_NOTIFY_DOMAIN.
+    Retrieve the SendGrid API key from tool_config or environment.
 
-    Raises:
-        ValueError: If the domain is not found in the tool configuration or environment variable.
+    Looks for an integration named "sendgrid" and reads configuration item
+    with name "apiKey". Falls back to env var SENDGRID_API_KEY.
     """
+    key: Optional[str] = None
     if tool_config:
-        mailgun_config = next(
-            (item for item in tool_config if item.get("name") == "mailgun"), None
+        cfg = next((c for c in tool_config if c.get("name") == "sendgrid"), None)
+        if cfg:
+            cfg_map = {i.get("name"): i.get("value") for i in cfg.get("configuration", []) if i}
+            key = cfg_map.get("apiKey")
+    key = key or os.getenv("SENDGRID_API_KEY")
+    if not key:
+        raise ValueError(
+            "SendGrid integration is not configured. Please configure the connection to SendGrid in Integrations."
         )
-        if mailgun_config:
-            config_map = {
-                item["name"]: item["value"]
-                for item in mailgun_config.get("configuration", [])
-                if item
-            }
-            MAILGUN_NOTIFY_DOMAIN = config_map.get("notifyDomain")
-        else:
-            MAILGUN_NOTIFY_DOMAIN = None
-    else:
-        MAILGUN_NOTIFY_DOMAIN = None
+    return key
 
-    MAILGUN_NOTIFY_DOMAIN = MAILGUN_NOTIFY_DOMAIN or os.getenv("MAILGUN_NOTIFY_DOMAIN")
-    if not MAILGUN_NOTIFY_DOMAIN:
-        raise ValueError("MAILGUN_NOTIFY_DOMAIN not found in tool_config or environment variable")
-    return MAILGUN_NOTIFY_DOMAIN
 
 @assistant_tool
-async def send_email_with_mailgun(sender: str, recipients: List[str], subject: str, message: str, tool_config: Optional[List[Dict]] = None):
+async def send_email_with_sendgrid(
+    sender: str,
+    recipients: List[str],
+    subject: str,
+    message: str,
+    tool_config: Optional[List[Dict]] = None,
+    body_format: Optional[str] = None,
+):
     """
-    Send an email using the Mailgun API.
+    Send an email using SendGrid's v3 Mail Send API.
 
     Parameters:
-    - **sender** (*str*): The email address of the sender.
-    - **recipients** (*List[str]*): A list of recipient email addresses.
-    - **subject** (*str*): The subject of the email.
-    - **message** (*str*): The HTML content of the email.
+    - sender: Either "Name <email@example.com>" or a plain e-mail address.
+    - recipients: List of recipient e-mail addresses.
+    - subject: Subject string.
+    - message: HTML body content.
+    - tool_config: Optional integration configuration list.
     """
+    api_key = get_sendgrid_api_key(tool_config)
+
+    name, email_addr = parseaddr(sender)
+    from_obj: Dict[str, str] = {"email": email_addr or sender}
+    if name:
+        from_obj["name"] = name
+
+    to_list = [{"email": r} for r in recipients if r]
+    if not to_list:
+        return {"error": "No recipients provided"}
+
+    plain_body, html_body, _ = body_variants(message, body_format)
+    content = [
+        {"type": "text/plain", "value": plain_body},
+        {"type": "text/html", "value": html_body},
+    ]
+
+    payload = {
+        "personalizations": [
+            {
+                "to": to_list,
+                "subject": subject,
+            }
+        ],
+        "from": from_obj,
+        "content": content,
+    }
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
     try:
-        # Retrieve Mailgun API key and domain from tool configuration or environment variables
-        api_key = get_mailgun_notify_key(tool_config)
-        domain = get_mailgun_notify_domain(tool_config)
-
-        # Prepare the data payload for the email
-        data = {
-            "from": sender,
-            "to": recipients,
-            "subject": subject,
-            "html": message,
-        }
-
-        # Create an asynchronous HTTP session
         async with aiohttp.ClientSession() as session:
-            # Send a POST request to the Mailgun API to send the email
             async with session.post(
-                f"https://api.mailgun.net/v3/{domain}/messages",
-                auth=aiohttp.BasicAuth("api", api_key),
-                data=data,
+                "https://api.sendgrid.com/v3/mail/send",
+                headers=headers,
+                json=payload,
             ) as response:
-                # Return the response text
-                return await response.text()
+                # SendGrid returns 202 Accepted on success with empty body
+                if response.status == 202:
+                    return {"status": 202, "message": "accepted"}
+                # On error, try to parse JSON for helpful message
+                try:
+                    err = await response.json()
+                except Exception:
+                    err = {"text": await response.text()}
+                return {"error": err, "status": response.status}
     except Exception as ex:
-        # Log any exceptions that occur and return an error message
-        logging.warning(f"Error sending email invite: {ex}")
-        return {"error": str(ex)}
+        logging.warning(f"Error sending email via SendGrid: {ex}")
+        return {"error": str(ex)}
+
+
+async def send_email_using_sendgrid_async(
+    ctx: SendEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    """
+    Provider-style wrapper for SendGrid using SendEmailContext.
+    Returns an opaque token since SendGrid does not return a message id.
+    """
+    plain_body, html_body, _ = body_variants(
+        ctx.body,
+        getattr(ctx, "body_format", None),
+    )
+    result = await send_email_with_sendgrid(
+        sender=f"{ctx.sender_name} <{ctx.sender_email}>",
+        recipients=[ctx.recipient],
+        subject=ctx.subject,
+        message=ctx.body or "",
+        body_format=getattr(ctx, "body_format", None),
+        tool_config=tool_config,
+    )
+    # Normalise output to a string id-like value
+    if isinstance(result, dict) and result.get("status") == 202:
+        return f"sent:{ctx.sender_email}:{ctx.recipient}:{ctx.subject}"
+    if isinstance(result, dict) and "error" in result:
+        raise RuntimeError(f"SendGrid send failed: {result['error']}")
+    return str(result)

dhisana/utils/serarch_router_local_business.py

@@ -0,0 +1,75 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+from dhisana.utils.assistant_tool_tag import assistant_tool
+
+# Your provider-specific helpers (paths may differ in your repo)
+from dhisana.utils.serperdev_local_business import search_local_business_serper
+from dhisana.utils.serpapi_local_business_search import search_local_business_serpai
+
+# Re-use your existing provider detector
+from dhisana.utils.search_router import detect_search_provider  # or copy the function shown earlier
+
+logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.INFO)
+
+
+@assistant_tool
+async def search_local_business_with_tools(
+    query: str,
+    number_of_results: int = 20,
+    offset: int = 0,
+    tool_config: Optional[List[Dict]] = None,
+    location: Optional[str] = None,
+) -> List[str]:
+    """
+    Router that returns local-business (Google Maps) results using whichever
+    provider is configured in `tool_config`.
+
+    Priority order:
+      1. Serper.dev   – uses `search_local_business_serper`
+      2. SerpApi      – uses `search_local_business_serpai`
+
+    Args:
+        query:               Search string (e.g. "plumbers near Almaden Valley").
+        number_of_results:   Desired row count (will paginate if > provider page size).
+        offset:              Page offset (0-based; converted to provider-specific page or start).
+        tool_config:         Dhisana tool-configuration blob listing available providers.
+        location:            Optional city/region hint (Serper + SerpApi both accept it).
+
+    Returns:
+        List[str]: Each element is a JSON-encoded dict with keys:
+                   full_name, organization_name, phone, organization_website,
+                   rating, reviews, address, google_maps_url.
+                   If no provider is configured, returns one item with an "error" key.
+    """
+    if not query:
+        logger.warning("Empty query received by local-business router.")
+        return []
+
+    provider = detect_search_provider(tool_config)
+    logger.debug("Local-business router chose provider: %s", provider)
+
+    if provider == "serperdev":
+        logger.info("Routing to Serper.dev local-business helper.")
+        return await search_local_business_serper(
+            query=query,
+            number_of_results=number_of_results,
+            offset=offset,
+            tool_config=tool_config,
+            location=location,
+        )
+
+    if provider == "serpapi":
+        logger.info("Routing to SerpApi local-business helper.")
+        return await search_local_business_serpai(
+            query=query,
+            number_of_results=number_of_results,
+            offset=offset,
+            tool_config=tool_config,
+            location=location,
+        )
+
+    logger.error("No supported local-business provider found in tool_config.")
+    return [json.dumps({"error": "No supported local-business provider configured."})]

dhisana/utils/serpapi_additional_tools.py

@@ -0,0 +1,290 @@
+import json
+import os
+import re
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlparse
+import aiohttp
+from bs4 import BeautifulSoup
+import urllib
+
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from dhisana.utils.cache_output_tools import cache_output, retrieve_output
+from dhisana.utils.web_download_parse_tools import fetch_html_content
+from dhisana.utils.search_router import search_google_with_tools
+
+import logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def get_serp_api_access_token(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieves the SERPAPI_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 SERPAPI_KEY access token.
+
+    Raises:
+        ValueError: If the SerpAPI integration has not been configured.
+    """
+    logger.info("Entering get_serp_api_access_token")
+    SERPAPI_KEY = None
+
+    if tool_config:
+        logger.debug(f"Tool config provided: {tool_config}")
+        serpapi_config = next(
+            (item for item in tool_config if item.get("name") == "serpapi"), None
+        )
+        if serpapi_config:
+            config_map = {
+                item["name"]: item["value"]
+                for item in serpapi_config.get("configuration", [])
+                if item
+            }
+            SERPAPI_KEY = config_map.get("apiKey")
+        else:
+            logger.warning("No 'serpapi' config item found in tool_config.")
+    else:
+        logger.debug("No tool_config provided or it's None.")
+
+    SERPAPI_KEY = SERPAPI_KEY or os.getenv("SERPAPI_KEY")
+    if not SERPAPI_KEY:
+        logger.error("SerpAPI integration is not configured.")
+        raise ValueError(
+            "SerpAPI integration is not configured. Please configure the connection to SerpAPI in Integrations."
+        )
+
+    logger.info("Retrieved SERPAPI_KEY successfully.")
+    return SERPAPI_KEY
+
+
+
+
+@assistant_tool
+async def search_google_maps(
+    query: str,
+    number_of_results: int = 3,
+    tool_config: Optional[List[Dict]] = None
+) -> List[str]:
+    """
+    Search Google Maps using SERP API and return the results as an array of serialized JSON strings.
+    
+    Parameters:
+    - query (str): The search query.
+    - number_of_results (int): The number of results to return.
+    """
+    logger.info("Entering search_google_maps")
+    if not query:
+        logger.warning("Empty query string provided for search_google_maps.")
+        return []
+
+    SERPAPI_KEY = get_serp_api_access_token(tool_config)
+    params = {
+        "q": query,
+        "num": number_of_results,
+        "api_key": SERPAPI_KEY,
+        "engine": "google_maps"
+    }
+    url = "https://serpapi.com/search"
+
+    logger.debug(f"Searching Google Maps with params: {params}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, params=params) as response:
+                logger.debug(f"Received status: {response.status}")
+                result = await response.json()
+                if response.status != 200:
+                    logger.warning(f"Non-200 response from SERP API: {result}")
+                    return [json.dumps({"error": result})]
+
+                serialized_results = [json.dumps(item) for item in result.get('local_results', [])]
+                logger.info(f"Returning {len(serialized_results)} map results.")
+                return serialized_results
+    except Exception as e:
+        logger.exception("Exception during search_google_maps request.")
+        return [json.dumps({"error": str(e)})]
+
+
+@assistant_tool
+async def search_google_news(
+    query: str,
+    number_of_results: int = 3,
+    tool_config: Optional[List[Dict]] = None
+) -> List[str]:
+    """
+    Search Google News using SERP API and return the results as an array of serialized JSON strings.
+    
+    Parameters:
+    - query (str): The search query.
+    - number_of_results (int): The number of results to return.
+    """
+    logger.info("Entering search_google_news")
+    if not query:
+        logger.warning("Empty query string provided for search_google_news.")
+        return []
+
+    SERPAPI_KEY = get_serp_api_access_token(tool_config)
+    params = {
+        "q": query,
+        "num": number_of_results,
+        "api_key": SERPAPI_KEY,
+        "engine": "google_news"
+    }
+    url = "https://serpapi.com/search"
+
+    logger.debug(f"Searching Google News with params: {params}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, params=params) as response:
+                logger.debug(f"Received status: {response.status}")
+                result = await response.json()
+                if response.status != 200:
+                    logger.warning(f"Non-200 response from SERP API: {result}")
+                    return [json.dumps({"error": result})]
+
+                serialized_results = [json.dumps(item) for item in result.get('news_results', [])]
+                logger.info(f"Returning {len(serialized_results)} news results.")
+                return serialized_results
+    except Exception as e:
+        logger.exception("Exception during search_google_news request.")
+        return [json.dumps({"error": str(e)})]
+
+
+@assistant_tool
+async def search_job_postings(
+    query: str,
+    number_of_results: int,
+    tool_config: Optional[List[Dict]] = None
+) -> List[str]:
+    """
+    Search for job postings using SERP API and return the results as an array of serialized JSON strings.
+    
+    Parameters:
+    - query (str): The search query.
+    - number_of_results (int): The number of results to return.
+    """
+    logger.info("Entering search_job_postings")
+    if not query:
+        logger.warning("Empty query string provided for search_job_postings.")
+        return []
+
+    SERPAPI_KEY = get_serp_api_access_token(tool_config)
+    params = {
+        "q": query,
+        "num": number_of_results,
+        "api_key": SERPAPI_KEY,
+        "engine": "google_jobs"
+    }
+    url = "https://serpapi.com/search"
+
+    logger.debug(f"Searching Google Jobs with params: {params}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, params=params) as response:
+                logger.debug(f"Received status: {response.status}")
+                result = await response.json()
+                if response.status != 200:
+                    logger.warning(f"Non-200 response from SERP API: {result}")
+                    return [json.dumps({"error": result})]
+
+                serialized_results = [json.dumps(item) for item in result.get('jobs_results', [])]
+                logger.info(f"Returning {len(serialized_results)} job posting results.")
+                return serialized_results
+    except Exception as e:
+        logger.exception("Exception during search_job_postings request.")
+        return [json.dumps({"error": str(e)})]
+
+
+@assistant_tool
+async def search_google_images(
+    query: str,
+    number_of_results: int,
+    tool_config: Optional[List[Dict]] = None
+) -> List[str]:
+    """
+    Search Google Images using SERP API and return the results as an array of serialized JSON strings.
+    
+    Parameters:
+    - query (str): The search query.
+    - number_of_results (int): The number of results to return.
+    """
+    logger.info("Entering search_google_images")
+    if not query:
+        logger.warning("Empty query string provided for search_google_images.")
+        return []
+
+    SERPAPI_KEY = get_serp_api_access_token(tool_config)
+    params = {
+        "q": query,
+        "num": number_of_results,
+        "api_key": SERPAPI_KEY,
+        "engine": "google_images"
+    }
+    url = "https://serpapi.com/search"
+
+    logger.debug(f"Searching Google Images with params: {params}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, params=params) as response:
+                logger.debug(f"Received status: {response.status}")
+                result = await response.json()
+                if response.status != 200:
+                    logger.warning(f"Non-200 response from SERP API: {result}")
+                    return [json.dumps({"error": result})]
+
+                serialized_results = [json.dumps(item) for item in result.get('images_results', [])]
+                logger.info(f"Returning {len(serialized_results)} image results.")
+                return serialized_results
+    except Exception as e:
+        logger.exception("Exception during search_google_images request.")
+        return [json.dumps({"error": str(e)})]
+
+
+@assistant_tool
+async def search_google_videos(
+    query: str,
+    number_of_results: int,
+    tool_config: Optional[List[Dict]] = None
+) -> List[str]:
+    """
+    Search Google Videos using SERP API and return the results as an array of serialized JSON strings.
+    
+    Parameters:
+    - query (str): The search query.
+    - number_of_results (int): The number of results to return.
+    """
+    logger.info("Entering search_google_videos")
+    if not query:
+        logger.warning("Empty query string provided for search_google_videos.")
+        return []
+
+    SERPAPI_KEY = get_serp_api_access_token(tool_config)
+    params = {
+        "q": query,
+        "num": number_of_results,
+        "api_key": SERPAPI_KEY,
+        "engine": "google_videos"
+    }
+    url = "https://serpapi.com/search"
+
+    logger.debug(f"Searching Google Videos with params: {params}")
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, params=params) as response:
+                logger.debug(f"Received status: {response.status}")
+                result = await response.json()
+                if response.status != 200:
+                    logger.warning(f"Non-200 response from SERP API: {result}")
+                    return [json.dumps({"error": result})]
+
+                serialized_results = [json.dumps(item) for item in result.get('video_results', [])]
+                logger.info(f"Returning {len(serialized_results)} video results.")
+                return serialized_results
+    except Exception as e:
+        logger.exception("Exception during search_google_videos request.")
+        return [json.dumps({"error": str(e)})]