dhisana 0.0.1.dev243__py3-none-any.whl

dhisana/utils/mailgun_tools.py

@@ -0,0 +1,156 @@
+import asyncio
+import logging
+import os
+from typing import Optional, List, Dict
+
+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
+
+
+def get_mailgun_notify_key(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieve the Mailgun API key from tool_config or environment.
+
+    Looks for an integration named "mailgun" and reads configuration item
+    with name "apiKey". Falls back to env var MAILGUN_NOTIFY_KEY.
+    """
+    key = None
+    if tool_config:
+        cfg = next((item for item in tool_config if item.get("name") == "mailgun"), None)
+        if cfg:
+            cfg_map = {i["name"]: i["value"] for i in cfg.get("configuration", []) if i}
+            key = cfg_map.get("apiKey")
+    key = key or os.getenv("MAILGUN_NOTIFY_KEY")
+    if not key:
+        raise ValueError(
+            "Mailgun integration is not configured. Please configure the connection to Mailgun in Integrations."
+        )
+    return key
+
+
+def get_mailgun_notify_domain(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieve the Mailgun domain from tool_config or environment.
+
+    Looks for an integration named "mailgun" and reads configuration item
+    with name "domain" (preferred) or legacy "notifyDomain".
+    Falls back to env var MAILGUN_DOMAIN, then MAILGUN_NOTIFY_DOMAIN.
+    """
+    domain = None
+    if tool_config:
+        cfg = next((item for item in tool_config if item.get("name") == "mailgun"), None)
+        if cfg:
+            cfg_map = {i["name"]: i["value"] for i in cfg.get("configuration", []) if i}
+            domain = cfg_map.get("domain") or cfg_map.get("notifyDomain")
+    domain = domain or os.getenv("MAILGUN_DOMAIN") or os.getenv("MAILGUN_NOTIFY_DOMAIN")
+    if not domain:
+        raise ValueError(
+            "Mailgun integration is not configured. Please configure the connection to Mailgun in Integrations."
+        )
+    return domain
+
+
+@assistant_tool
+async def send_email_with_mailgun(
+    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.
+
+    Parameters:
+    - sender: Email address string, e.g. "Alice <alice@example.com>" or just address.
+    - recipients: List of recipient email addresses.
+    - subject: Subject string.
+    - message: HTML content body.
+    - tool_config: Optional integrations config list.
+    """
+    try:
+        api_key = get_mailgun_notify_key(tool_config)
+        domain = get_mailgun_notify_domain(tool_config)
+
+        body = message or ""
+        data = {
+            "from": sender,
+            "to": recipients,
+            "subject": subject,
+        }
+
+        plain_body, html_body, _ = body_variants(body, body_format)
+        data["text"] = plain_body
+        data["html"] = html_body
+
+        async with aiohttp.ClientSession() as session:
+            async with session.post(
+                f"https://api.mailgun.net/v3/{domain}/messages",
+                auth=aiohttp.BasicAuth("api", api_key),
+                data=data,
+            ) as response:
+                # Try to return JSON payload if available
+                try:
+                    return await response.json()
+                except Exception:
+                    return await response.text()
+    except Exception as ex:
+        logging.warning(f"Error sending email via Mailgun: {ex}")
+        return {"error": str(ex)}
+
+
+async def send_email_using_mailgun_async(
+    send_email_context: SendEmailContext,
+    tool_config: Optional[List[Dict]] = None,
+) -> str:
+    """
+    Provider-style wrapper for Mailgun that accepts SendEmailContext and returns an id string.
+    """
+    api_key = get_mailgun_notify_key(tool_config)
+    domain = get_mailgun_notify_domain(tool_config)
+
+    plain_body, html_body, _ = body_variants(
+        send_email_context.body,
+        getattr(send_email_context, "body_format", None),
+    )
+
+    data = {
+        "from": f"{send_email_context.sender_name} <{send_email_context.sender_email}>",
+        "to": [send_email_context.recipient],
+        "subject": send_email_context.subject,
+        "text": plain_body,
+        "html": html_body,
+    }
+
+    extra_headers = getattr(send_email_context, "headers", None) or {}
+    for header, value in extra_headers.items():
+        if not header or value is None:
+            continue
+        data[f"h:{header}"] = str(value)
+
+    async with aiohttp.ClientSession() as session:
+        async with session.post(
+            f"https://api.mailgun.net/v3/{domain}/messages",
+            auth=aiohttp.BasicAuth("api", api_key),
+            data=data,
+        ) as response:
+            # Raise if not 2xx to match other providers' behavior
+            if response.status < 200 or response.status >= 300:
+                try:
+                    detail = await response.text()
+                except Exception:
+                    detail = f"status={response.status}"
+                raise RuntimeError(f"Mailgun send failed: {detail}")
+            try:
+                payload = await response.json()
+            except Exception:
+                payload = {"message": await response.text()}
+
+    # Normalise return value akin to other providers
+    msg_id = payload.get("id") if isinstance(payload, dict) else None
+    await asyncio.sleep(20)
+    return msg_id or str(payload)

dhisana/utils/mailreach_tools.py

@@ -0,0 +1,123 @@
+import os
+import aiohttp
+import logging
+from typing import List, Dict, Any, Optional
+from dhisana.utils.assistant_tool_tag import assistant_tool
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+base_url = 'https://api.mailreach.co/api/v1'
+
+
+def get_mailreach_api_key(tool_config: Optional[List[Dict]] = None) -> str:
+    """
+    Retrieves the MailReach API key from the provided 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.
+
+    Returns:
+        str: The MailReach API key.
+
+    Raises:
+        ValueError: If the MailReach integration has not been configured.
+    """
+    api_key = None
+    
+    if tool_config:
+        mailreach_config = next(
+            (item for item in tool_config if item.get("name") == "mailreach"), None
+        )
+        if mailreach_config:
+            config_map = {
+                item["name"]: item["value"]
+                for item in mailreach_config.get("configuration", [])
+                if item
+            }
+            api_key = config_map.get("apiKey")
+    
+    api_key = api_key or os.getenv("MAILREACH_API_KEY")
+    
+    if not api_key:
+        raise ValueError(
+            "MailReach integration is not configured. Please configure the connection to MailReach in Integrations."
+        )
+    
+    return api_key
+
+
+def get_mailreach_headers(tool_config: Optional[List[Dict]] = None) -> Dict[str, str]:
+    """
+    Get the headers required for MailReach API requests.
+
+    Args:
+        tool_config (list): Optional tool configuration containing API credentials.
+
+    Returns:
+        Dict[str, str]: Headers dictionary with x-api-key and Content-Type.
+    """
+    api_key = get_mailreach_api_key(tool_config)
+    headers = {
+        "x-api-key": api_key,
+        "Content-Type": "application/json"
+    }
+    return headers
+
+
+async def _handle_mailreach_response(response: aiohttp.ClientResponse) -> Any:
+    """
+    Handle MailReach API responses consistently.
+
+    Args:
+        response: The aiohttp ClientResponse object.
+
+    Returns:
+        The JSON response data.
+
+    Raises:
+        aiohttp.ClientResponseError: For rate limits or other errors.
+    """
+    if response.status == 200:
+        return await response.json()
+    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:
+        error_message = await response.text()
+        logger.error(f"MailReach API Error {response.status}: {error_message}")
+        response.raise_for_status()
+
+
+@assistant_tool
+async def ping_mailreach(
+    tool_config: Optional[List[Dict]] = None
+) -> Dict[str, Any]:
+    """
+    Ping the MailReach API to verify connectivity and authentication.
+    
+    This is a simple endpoint to test if your API key is valid and the service is accessible.
+
+    Args:
+        tool_config (list): Optional tool configuration containing API credentials.
+
+    Returns:
+        Dict[str, Any]: Response from the ping endpoint, typically containing a success message.
+    """
+    url = f"{base_url}/ping"
+    headers = get_mailreach_headers(tool_config)
+    
+    logger.info("Pinging MailReach API...")
+    
+    async with aiohttp.ClientSession() as session:
+        async with session.get(url, headers=headers) as response:
+            result = await _handle_mailreach_response(response)
+            logger.info("MailReach ping successful")
+            return result