dhisana 0.0.1.dev239__tar.gz → 0.0.1.dev241__tar.gz

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/PKG-INFO

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

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/setup.py

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

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/schemas/common.py

@@ -378,6 +378,7 @@ class SendEmailContext(BaseModel):
     sender_email: str
     labels: Optional[List[str]]
     body_format: BodyFormat = BodyFormat.AUTO
+    headers: Optional[Dict[str, str]] = None
     
 class QueryEmailContext(BaseModel):
     start_time: str

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/google_oauth_tools.py

@@ -145,6 +145,12 @@ async def send_email_using_google_oauth_async(
     message["from"] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
     message["subject"] = send_email_context.subject
 
+    extra_headers = getattr(send_email_context, "headers", None) or {}
+    for header, value in extra_headers.items():
+        if not header or value is None:
+            continue
+        message[header] = str(value)
+
     raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode()
 
     payload: Dict[str, Any] = {"raw": raw_message}

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/google_workspace_tools.py

@@ -179,6 +179,12 @@ async def send_email_using_service_account_async(
     message['from'] = f"{send_email_context.sender_name} <{send_email_context.sender_email}>"
     message['subject'] = send_email_context.subject
 
+    extra_headers = getattr(send_email_context, "headers", None) or {}
+    for header, value in extra_headers.items():
+        if not header or value is None:
+            continue
+        message[header] = str(value)
+
     # Base64-encode the message
     raw_message = base64.urlsafe_b64encode(message.as_bytes()).decode()
 
@@ -531,6 +537,7 @@ class SendEmailContext(BaseModel):
     sender_email: str
     labels: Optional[List[str]]
     body_format: BodyFormat = BodyFormat.AUTO
+    headers: Optional[Dict[str, str]] = None
     
 @assistant_tool
 async def send_email_using_service_account_async(

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/mailgun_tools.py

@@ -126,6 +126,12 @@ async def send_email_using_mailgun_async(
         "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",

dhisana-0.0.1.dev241/src/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

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/microsoft365_tools.py

@@ -168,6 +168,14 @@ async def send_email_using_microsoft_graph_async(
         ],
     }
 
+    extra_headers = getattr(send_email_context, "headers", None) or {}
+    if extra_headers:
+        message_payload["internetMessageHeaders"] = [
+            {"name": header, "value": str(value)}
+            for header, value in extra_headers.items()
+            if header and value is not None
+        ]
+
     headers = {
         "Authorization": f"Bearer {token}",
         "Content-Type": "application/json",

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/sendgrid_tools.py

@@ -59,6 +59,7 @@ async def send_email_with_sendgrid(
     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.
@@ -69,6 +70,7 @@ async def send_email_with_sendgrid(
     - 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)
 
@@ -98,6 +100,13 @@ async def send_email_with_sendgrid(
         "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",
@@ -143,6 +152,7 @@ async def send_email_using_sendgrid_async(
         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:

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/smtp_email_tools.py

@@ -174,6 +174,12 @@ async def send_email_via_smtp_async(
     generated_id = f"<{uuid.uuid4()}@{domain_part}>"
     msg["Message-ID"] = generated_id
 
+    extra_headers = getattr(ctx, "headers", None) or {}
+    for header, value in extra_headers.items():
+        if not header or value is None:
+            continue
+        msg[header] = str(value)
+
     smtp_kwargs = dict(
         hostname=smtp_server,
         port=smtp_port,

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana/utils/test_connect.py

@@ -483,6 +483,31 @@ async def test_sendgrid(api_key: str) -> Dict[str, Any]:
         return {"success": False, "status_code": 0, "error_message": str(e)}
 
 
+async def test_mailreach(api_key: str) -> Dict[str, Any]:
+    """
+    Basic MailReach connectivity check using the Ping endpoint.
+    
+    Uses the /v1/ping endpoint to verify API key validity and service availability.
+    Reference: https://docs.mailreach.co/reference/getv1ping
+    """
+    url = "https://api.mailreach.co/api/v1/ping"
+    headers = {"x-api-key": api_key}
+    try:
+        async with aiohttp.ClientSession(timeout=aiohttp.ClientTimeout(total=10)) as session:
+            async with session.get(url, headers=headers) as response:
+                status = response.status
+                data = await safe_json(response)
+                if status != 200:
+                    msg = None
+                    if data and isinstance(data, dict):
+                        msg = data.get("message") or data.get("error")
+                    return {"success": False, "status_code": status, "error_message": msg or f"MailReach non-200: {status}"}
+                return {"success": True, "status_code": status, "error_message": None}
+    except Exception as e:
+        logger.error(f"MailReach test failed: {e}")
+        return {"success": False, "status_code": 0, "error_message": str(e)}
+
+
 async def test_samgov(api_key: str) -> Dict[str, Any]:
     """Test SAM.gov connectivity by fetching a single opportunity."""
 
@@ -1789,6 +1814,7 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "mcpServer":        test_mcp_server,
         "slack":            test_slack,
         "mailgun":          test_mailgun,
+        "mailreach":        test_mailreach,
         "sendgrid":         test_sendgrid,
         "samgov":          test_samgov,
         "scraperapi":       test_scraperapi,

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana.egg-info/PKG-INFO

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

{dhisana-0.0.1.dev239 → dhisana-0.0.1.dev241}/src/dhisana.egg-info/SOURCES.txt

@@ -63,6 +63,7 @@ src/dhisana/utils/instantly_tools.py
 src/dhisana/utils/linkedin_crawler.py
 src/dhisana/utils/lusha_tools.py
 src/dhisana/utils/mailgun_tools.py
+src/dhisana/utils/mailreach_tools.py
 src/dhisana/utils/microsoft365_tools.py
 src/dhisana/utils/openai_assistant_and_file_utils.py
 src/dhisana/utils/openai_helpers.py
@@ -110,6 +111,7 @@ tests/test_email_body_utils.py
 tests/test_google_document.py
 tests/test_hubspot_call_logs.py
 tests/test_linkedin_serper.py
+tests/test_mailreach.py
 tests/test_mcp_connectivity.py
 tests/test_proxycurl_get_company_search_id.py
 tests/test_proxycurl_job_count.py

dhisana-0.0.1.dev241/tests/test_mailreach.py

@@ -0,0 +1,179 @@
+import asyncio
+import unittest
+import os
+from unittest.mock import AsyncMock, MagicMock, patch
+
+# Test imports
+from src.dhisana.utils.mailreach_tools import (
+    get_mailreach_api_key,
+    get_mailreach_headers,
+    ping_mailreach
+)
+from src.dhisana.utils.test_connect import test_mailreach
+
+
+class TestMailReachTools(unittest.TestCase):
+    """Test suite for MailReach integration tools."""
+    
+    def test_get_mailreach_api_key_from_config(self):
+        """Test retrieving API key from tool configuration."""
+        tool_config = [
+            {
+                'name': 'mailreach',
+                'configuration': [
+                    {'name': 'apiKey', 'value': 'test_api_key_123'}
+                ]
+            }
+        ]
+        api_key = get_mailreach_api_key(tool_config)
+        self.assertEqual(api_key, 'test_api_key_123')
+    
+    def test_get_mailreach_api_key_from_env(self):
+        """Test retrieving API key from environment variable."""
+        with patch.dict(os.environ, {'MAILREACH_API_KEY': 'env_api_key_456'}):
+            api_key = get_mailreach_api_key()
+            self.assertEqual(api_key, 'env_api_key_456')
+    
+    def test_get_mailreach_api_key_missing(self):
+        """Test that missing API key raises ValueError."""
+        with patch.dict(os.environ, {}, clear=True):
+            with self.assertRaises(ValueError) as context:
+                get_mailreach_api_key()
+            self.assertIn('not configured', str(context.exception))
+    
+    def test_get_mailreach_headers(self):
+        """Test that headers are properly formatted."""
+        tool_config = [
+            {
+                'name': 'mailreach',
+                'configuration': [
+                    {'name': 'apiKey', 'value': 'test_key'}
+                ]
+            }
+        ]
+        headers = get_mailreach_headers(tool_config)
+        self.assertEqual(headers['x-api-key'], 'test_key')
+        self.assertEqual(headers['Content-Type'], 'application/json')
+    
+    def test_ping_mailreach_success(self):
+        """Test successful ping to MailReach API."""
+        async def runner():
+            tool_config = [
+                {
+                    'name': 'mailreach',
+                    'configuration': [
+                        {'name': 'apiKey', 'value': 'test_api_key'}
+                    ]
+                }
+            ]
+            
+            mock_response = AsyncMock()
+            mock_response.status = 200
+            mock_response.json = AsyncMock(return_value={'message': 'pong', 'status': 'ok'})
+            
+            mock_get = AsyncMock()
+            mock_get.__aenter__.return_value = mock_response
+            
+            with patch('aiohttp.ClientSession') as mock_session:
+                mock_session.return_value.__aenter__.return_value.get = MagicMock(return_value=mock_get)
+                
+                result = await ping_mailreach(tool_config)
+                
+                self.assertIsInstance(result, dict)
+                self.assertEqual(result.get('message'), 'pong')
+        
+        asyncio.run(runner())
+    
+    def test_ping_mailreach_rate_limit(self):
+        """Test rate limit handling in ping."""
+        async def runner():
+            tool_config = [
+                {
+                    'name': 'mailreach',
+                    'configuration': [
+                        {'name': 'apiKey', 'value': 'test_api_key'}
+                    ]
+                }
+            ]
+            
+            mock_response = AsyncMock()
+            mock_response.status = 429
+            mock_response.text = AsyncMock(return_value='Rate limit exceeded')
+            mock_response.request_info = MagicMock()
+            mock_response.history = []
+            mock_response.headers = {}
+            
+            mock_get = AsyncMock()
+            mock_get.__aenter__.return_value = mock_response
+            
+            with patch('aiohttp.ClientSession') as mock_session:
+                mock_session.return_value.__aenter__.return_value.get = MagicMock(return_value=mock_get)
+                
+                with self.assertRaises(Exception):
+                    await ping_mailreach(tool_config)
+        
+        asyncio.run(runner())
+
+
+class TestMailReachConnectivity(unittest.TestCase):
+    """Test suite for MailReach connectivity check."""
+    
+    def test_mailreach_connection_success(self):
+        """Test successful MailReach connection."""
+        async def runner():
+            mock_response = AsyncMock()
+            mock_response.status = 200
+            mock_response.json = AsyncMock(return_value={'message': 'pong'})
+            
+            mock_get = AsyncMock()
+            mock_get.__aenter__.return_value = mock_response
+            
+            with patch('aiohttp.ClientSession') as mock_session:
+                mock_session.return_value.__aenter__.return_value.get = MagicMock(return_value=mock_get)
+                
+                result = await test_mailreach('test_api_key')
+                
+                self.assertTrue(result['success'])
+                self.assertEqual(result['status_code'], 200)
+                self.assertIsNone(result['error_message'])
+        
+        asyncio.run(runner())
+    
+    def test_mailreach_connection_invalid_key(self):
+        """Test MailReach connection with invalid API key."""
+        async def runner():
+            mock_response = AsyncMock()
+            mock_response.status = 401
+            mock_response.json = AsyncMock(return_value={'error': 'Invalid API key'})
+            
+            mock_get = AsyncMock()
+            mock_get.__aenter__.return_value = mock_response
+            
+            with patch('aiohttp.ClientSession') as mock_session:
+                mock_session.return_value.__aenter__.return_value.get = MagicMock(return_value=mock_get)
+                
+                result = await test_mailreach('invalid_key')
+                
+                self.assertFalse(result['success'])
+                self.assertEqual(result['status_code'], 401)
+                self.assertIsNotNone(result['error_message'])
+        
+        asyncio.run(runner())
+    
+    def test_mailreach_connection_timeout(self):
+        """Test MailReach connection timeout."""
+        async def runner():
+            with patch('aiohttp.ClientSession') as mock_session:
+                mock_session.return_value.__aenter__.return_value.get.side_effect = asyncio.TimeoutError()
+                
+                result = await test_mailreach('test_api_key')
+                
+                self.assertFalse(result['success'])
+                self.assertEqual(result['status_code'], 0)
+                self.assertIsNotNone(result['error_message'])
+        
+        asyncio.run(runner())
+
+
+if __name__ == '__main__':
+    unittest.main()