dhisana 0.0.1.dev243__py3-none-any.whl

dhisana/utils/sendgrid_tools.py

@@ -0,0 +1,162 @@
+"""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.schemas.common import SendEmailContext
+from dhisana.utils.email_body_utils import body_variants
+
+# --------------------------------------------------------------------------- #
+# 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,
+)
+
+
+# --------------------------------------------------------------------------- #
+# SendGrid helpers
+# --------------------------------------------------------------------------- #
+
+def get_sendgrid_api_key(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieve the SendGrid API key from tool_config or environment.
+
+    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:
+        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."
+        )
+    return key
+
+
+@assistant_tool
+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,
+    custom_headers: Optional[Dict[str, str]] = None,
+):
+    """
+    Send an email using SendGrid's v3 Mail Send API.
+
+    Parameters:
+    - 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.
+    - custom_headers: Optional mapping of header names to values.
+    """
+    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,
+    }
+
+    if custom_headers:
+        payload["headers"] = {
+            header: str(value)
+            for header, value in custom_headers.items()
+            if header and value is not None
+        }
+
+    headers = {
+        "Authorization": f"Bearer {api_key}",
+        "Content-Type": "application/json",
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                "https://api.sendgrid.com/v3/mail/send",
+                headers=headers,
+                json=payload,
+            ) as response:
+                # 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:
+        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,
+        custom_headers=getattr(ctx, "headers", None),
+    )
+    # 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)})]

dhisana/utils/serpapi_google_jobs.py

@@ -0,0 +1,117 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+
+from dhisana.utils.assistant_tool_tag import assistant_tool
+from dhisana.utils.cache_output_tools import cache_output, retrieve_output
+from dhisana.utils.serpapi_google_search import get_serp_api_access_token
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def _normalise_job_result(raw: Dict[str, Any]) -> Dict[str, Any]:
+    """Convert a SerpApi jobs result to a simplified schema."""
+    # ...existing code...
+    apply_link = ""
+    apply_options = raw.get("apply_options") or raw.get("apply_links") or []
+    if isinstance(apply_options, list) and apply_options:
+        first = apply_options[0]
+        if isinstance(first, dict):
+            apply_link = first.get("link") or first.get("apply_link") or ""
+    if isinstance(apply_options, dict):
+        apply_link = apply_options.get("link") or apply_options.get("apply_link") or ""
+
+    return {
+        "job_title": raw.get("title", ""),
+        "organization_name": raw.get("company_name") or raw.get("company", ""),
+        "location": raw.get("location", ""),
+        "via": raw.get("via", ""),
+        "description": raw.get("description", ""),
+        "job_posting_url": raw.get("job_highlight_url")
+        or raw.get("apply_link")
+        or apply_link
+        or raw.get("link", ""),
+    }
+
+
+@assistant_tool
+async def search_google_jobs_serpapi(
+    query: str,
+    number_of_results: int = 10,
+    offset: int = 0,
+    tool_config: Optional[List[Dict]] = None,
+    location: Optional[str] = None,
+) -> List[str]:
+    """Search Google Jobs via SerpApi and return normalised JSON strings."""
+    if not query:
+        logger.warning("Empty query provided to search_google_jobs_serpapi")
+        return []
+
+    cache_key = f"jobs_serpapi_{query}_{number_of_results}_{offset}_{location or ''}"
+    cached = retrieve_output("search_google_jobs_serpapi", cache_key)
+    if cached is not None:
+        return cached
+
+    api_key = get_serp_api_access_token(tool_config)
+    page_size = 10
+    collected: List[Dict[str, Any]] = []
+    next_page_token = None
+
+    async with aiohttp.ClientSession() as session:
+        while len(collected) < number_of_results:
+            to_fetch = min(page_size, number_of_results - len(collected))
+            params = {
+                "engine": "google_jobs",
+                "q": query,
+                "api_key": api_key,
+                "num": to_fetch,
+            }
+            
+            if offset > 0 and next_page_token is None:
+                # If offset is provided but we don't have a token yet,
+                # we can't properly paginate. Log a warning.
+                logger.warning("Offset provided but next_page_token not available. Results may be incomplete.")
+                
+            if next_page_token:
+                params["next_page_token"] = next_page_token
+                
+            if location:
+                params["location"] = location
+                
+            try:
+                async with session.get("https://serpapi.com/search", params=params) as resp:
+                    if resp.status != 200:
+                        try:
+                            err = await resp.json()
+                        except Exception:
+                            err = await resp.text()
+                        logger.warning("SerpApi jobs error: %s", err)
+                        return [json.dumps({"error": err})]
+                    payload = await resp.json()
+            except Exception as exc:
+                logger.exception("SerpApi jobs request failed")
+                return [json.dumps({"error": str(exc)})]
+
+            jobs = payload.get("jobs_results", [])
+            if not jobs:
+                break
+                
+            collected.extend(jobs)
+            
+            # Get the next_page_token for pagination
+            next_page_token = payload.get("serpapi_pagination", {}).get("next_page_token")
+            if not next_page_token:
+                break
+            
+            # If we've collected enough results, stop pagination
+            if len(collected) >= number_of_results:
+                break
+
+    normalised = [_normalise_job_result(j) for j in collected[:number_of_results]]
+    serialised = [json.dumps(item) for item in normalised]
+    cache_output("search_google_jobs_serpapi", cache_key, serialised)
+    logger.info("Returned %d job results for '%s'", len(serialised), query)
+    return serialised