dhisana 0.0.1.dev310__tar.gz → 0.0.1.dev312__tar.gz

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/PKG-INFO

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

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/setup.py

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

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/src/dhisana/utils/microsoft365_tools.py

@@ -598,12 +598,35 @@ async def reply_to_email_m365_async(
             create_reply_url = (
                 f"{base_url}{base_res}/messages/{reply_email_context.message_id}/createReplyAll"
             )
-        create_payload = {"comment": reply_email_context.reply_body}
+        # Resolve plain-text and HTML variants of the reply body.
+        # We always create the draft with {"comment": ""} so that Graph
+        # auto-generates the quoted conversation thread, then patch the
+        # body for HTML replies to preserve that quoted content.
+        plain_reply, html_reply, resolved_fmt = body_variants(
+            reply_email_context.reply_body,
+            reply_email_context.reply_body_format,
+        )
+
+        if resolved_fmt == "html":
+            # Create draft with empty comment so Graph generates quoted thread
+            create_payload: Dict[str, Any] = {"comment": ""}
+        else:
+            create_payload = {"comment": plain_reply}
         create_resp = await client.post(create_reply_url, headers=headers, json=create_payload)
         create_resp.raise_for_status()
         reply_msg = create_resp.json()
         reply_id = reply_msg.get("id")
 
+        if resolved_fmt == "html":
+            # Prepend the HTML reply above the Graph-generated quoted thread
+            existing_body = reply_msg.get("body", {}).get("content", "")
+            merged_body = html_reply + existing_body
+            patch_body_url = f"{base_url}{base_res}/messages/{reply_id}"
+            patch_body_resp = await client.patch(patch_body_url, headers=headers, json={
+                "body": {"contentType": "html", "content": merged_body}
+            })
+            patch_body_resp.raise_for_status()
+
         # 3) Optionally update recipients/subject and add categories (labels) to the draft
         patch_payload: Dict[str, Any] = {}
         if to_recipients:

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/src/dhisana/utils/smtp_email_tools.py

@@ -726,8 +726,17 @@ async def reply_to_email_via_smtp_async(
     else:
         references = orig_msg_id
 
-    # 3. Build the MIMEText reply
-    msg = MIMEText(ctx.reply_body, _charset="utf-8")
+    # 3. Build the reply MIME (honor reply_body_format for HTML emails)
+    plain_reply, html_reply, resolved_reply_fmt = body_variants(
+        ctx.reply_body,
+        ctx.reply_body_format,
+    )
+    if resolved_reply_fmt == "text":
+        msg = MIMEText(plain_reply, "plain", _charset="utf-8")
+    else:
+        msg = MIMEMultipart("alternative")
+        msg.attach(MIMEText(plain_reply, "plain", _charset="utf-8"))
+        msg.attach(MIMEText(html_reply, "html", _charset="utf-8"))
     sender_display = ctx.sender_name or ctx.sender_email
     msg["From"] = f"{sender_display} <{ctx.sender_email}>"
     msg["To"] = to_addrs

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/src/dhisana/utils/test_connect.py

@@ -2234,6 +2234,71 @@ async def test_gemini(
         return {"success": False, "status_code": 0, "error_message": err_msg}
 
 
+###############################################################################
+#                           BUILTWITH CONNECTIVITY
+###############################################################################
+
+async def test_builtwith(api_key: str) -> Dict[str, Any]:
+    """
+    Connectivity test for BuiltWith using the Domain API v22.
+
+    Performs a lightweight lookup of ``example.com`` to verify the API key is
+    valid and the account has remaining credits.
+    """
+    url = "https://api.builtwith.com/v22/api.json"
+    headers = {
+        "Accept": "application/json",
+    }
+    params = {
+        "KEY": api_key,
+        "LOOKUP": "example.com",
+        "HIDEDL": "yes",
+        "NOPII": "yes",
+        "LIVEONLY": "yes",
+    }
+
+    try:
+        timeout = aiohttp.ClientTimeout(total=15)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            async with session.get(url, headers=headers, params=params) as resp:
+                status = resp.status
+                data = await safe_json(resp)
+
+                if status == 200:
+                    # A valid key returns a JSON object; check for error key
+                    if isinstance(data, dict):
+                        errors = data.get("Errors")
+                        if errors:
+                            return {
+                                "success": False,
+                                "status_code": status,
+                                "error_message": str(errors),
+                            }
+                    return {"success": True, "status_code": status, "error_message": None}
+
+                if status in (401, 403):
+                    msg = None
+                    if isinstance(data, dict):
+                        msg = data.get("Errors") or data.get("message") or data.get("error")
+                    return {
+                        "success": False,
+                        "status_code": status,
+                        "error_message": str(msg) if msg else "Unauthorized \u2013 check BuiltWith API key",
+                    }
+
+                msg = None
+                if isinstance(data, dict):
+                    msg = data.get("Errors") or data.get("message") or data.get("error")
+                return {
+                    "success": False,
+                    "status_code": status,
+                    "error_message": str(msg) if msg else f"BuiltWith responded with {status}",
+                }
+    except Exception as e:
+        logger.error(f"BuiltWith connectivity test failed: {e}")
+        return {"success": False, "status_code": 0, "error_message": str(e)}
+
+
 ###############################################################################
 #                         MAIN CONNECTIVITY FUNCTION
 ###############################################################################
@@ -2293,6 +2358,7 @@ async def test_connectivity(tool_config: List[Dict[str, Any]]) -> Dict[str, Dict
         "samgov":          test_samgov,
         "scraperapi":       test_scraperapi,
         "gemini":           test_gemini,
+        "builtwith":        test_builtwith,
     }
 
     results: Dict[str, Dict[str, Any]] = {}

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/src/dhisana.egg-info/PKG-INFO

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

{dhisana-0.0.1.dev310 → dhisana-0.0.1.dev312}/src/dhisana.egg-info/SOURCES.txt

@@ -121,6 +121,7 @@ tests/test_mcp_connectivity.py
 tests/test_normalize_graph_datetime.py
 tests/test_proxycurl_get_company_search_id.py
 tests/test_proxycurl_job_count.py
+tests/test_reply_html_format.py
 tests/test_reply_thread_fallback.py
 tests/test_send_email_recipients.py
 tests/test_structured_output_with_mcp.py

dhisana-0.0.1.dev312/tests/test_reply_html_format.py

@@ -0,0 +1,256 @@
+"""Tests for HTML reply body formatting across SMTP and M365 providers.
+
+Validates that reply_body_format=HTML is honoured so that follow-up
+emails in a campaign are sent as HTML rather than plain text.
+"""
+
+import asyncio
+import base64
+import email as email_lib
+import json
+from email.mime.multipart import MIMEMultipart
+from email.mime.text import MIMEText
+from typing import Any, Dict
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import httpx
+import pytest
+
+from dhisana.schemas.common import BodyFormat, ReplyEmailContext
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _make_response(status_code: int, json_body: Any = None) -> httpx.Response:
+    resp = httpx.Response(
+        status_code=status_code,
+        request=httpx.Request("GET", "https://example.com"),
+        content=json.dumps(json_body or {}).encode(),
+    )
+    return resp
+
+
+HTML_BODY = "<p>Hello <strong>World</strong></p>"
+PLAIN_BODY = "Hello World"
+
+
+# ---------------------------------------------------------------------------
+# SMTP reply tests
+# ---------------------------------------------------------------------------
+
+class TestSmtpReplyHtmlFormat:
+    """reply_to_email_via_smtp_async must build a multipart/alternative MIME
+    message when reply_body_format is HTML."""
+
+    @pytest.fixture
+    def smtp_ctx_html(self):
+        return ReplyEmailContext(
+            message_id="<orig@example.com>",
+            reply_body=HTML_BODY,
+            sender_email="sender@example.com",
+            sender_name="Sender",
+            fallback_recipient="recipient@example.com",
+            reply_body_format=BodyFormat.HTML,
+        )
+
+    @pytest.fixture
+    def smtp_ctx_text(self):
+        return ReplyEmailContext(
+            message_id="<orig@example.com>",
+            reply_body=PLAIN_BODY,
+            sender_email="sender@example.com",
+            sender_name="Sender",
+            fallback_recipient="recipient@example.com",
+            reply_body_format=BodyFormat.TEXT,
+        )
+
+    @pytest.mark.asyncio
+    async def test_html_reply_produces_multipart(self, smtp_ctx_html):
+        """When reply_body_format=HTML, the MIME should be multipart/alternative
+        with both plain and HTML parts."""
+        from dhisana.utils.smtp_email_tools import reply_to_email_via_smtp_async
+
+        raw_original = self._build_raw_original()
+
+        with patch("dhisana.utils.smtp_email_tools.asyncio") as mock_asyncio, \
+             patch("dhisana.utils.smtp_email_tools.aiosmtplib") as mock_aiosmtp:
+
+            mock_asyncio.to_thread = AsyncMock(return_value=raw_original)
+            mock_aiosmtp.send = AsyncMock(return_value=None)
+
+            result = await reply_to_email_via_smtp_async(
+                smtp_ctx_html,
+                smtp_server="smtp.example.com",
+                smtp_port=587,
+                imap_server="imap.example.com",
+                imap_port=993,
+                username="user",
+                password="pass",
+            )
+
+            # Verify aiosmtplib.send was called
+            mock_aiosmtp.send.assert_awaited_once()
+            sent_msg = mock_aiosmtp.send.call_args[0][0]
+
+            # The message should be multipart/alternative
+            assert sent_msg.get_content_type() == "multipart/alternative"
+            parts = sent_msg.get_payload()
+            assert len(parts) == 2
+
+            plain_part = parts[0]
+            html_part = parts[1]
+            assert plain_part.get_content_type() == "text/plain"
+            assert html_part.get_content_type() == "text/html"
+            assert HTML_BODY in html_part.get_payload(decode=True).decode()
+
+    @pytest.mark.asyncio
+    async def test_text_reply_produces_plain(self, smtp_ctx_text):
+        """When reply_body_format=TEXT, the MIME should be text/plain."""
+        from dhisana.utils.smtp_email_tools import reply_to_email_via_smtp_async
+
+        raw_original = self._build_raw_original()
+
+        with patch("dhisana.utils.smtp_email_tools.asyncio") as mock_asyncio, \
+             patch("dhisana.utils.smtp_email_tools.aiosmtplib") as mock_aiosmtp:
+
+            mock_asyncio.to_thread = AsyncMock(return_value=raw_original)
+            mock_aiosmtp.send = AsyncMock(return_value=None)
+
+            result = await reply_to_email_via_smtp_async(
+                smtp_ctx_text,
+                smtp_server="smtp.example.com",
+                smtp_port=587,
+                imap_server="imap.example.com",
+                imap_port=993,
+                username="user",
+                password="pass",
+            )
+
+            mock_aiosmtp.send.assert_awaited_once()
+            sent_msg = mock_aiosmtp.send.call_args[0][0]
+
+            assert sent_msg.get_content_type() == "text/plain"
+
+    def _build_raw_original(self) -> bytes:
+        """Build a minimal raw email message for IMAP fetch simulation."""
+        msg = MIMEText("Original body", "plain", "utf-8")
+        msg["From"] = "recipient@example.com"
+        msg["To"] = "sender@example.com"
+        msg["Subject"] = "Test"
+        msg["Message-ID"] = "<orig@example.com>"
+        return msg.as_bytes()
+
+
+# ---------------------------------------------------------------------------
+# Microsoft 365 reply tests
+# ---------------------------------------------------------------------------
+
+class TestM365ReplyHtmlFormat:
+    """reply_to_email_m365_async must create an empty-comment draft, then PATCH
+    the body with HTML content when reply_body_format is HTML."""
+
+    def _m365_original_message(self) -> Dict[str, Any]:
+        return {
+            "id": "msg_123",
+            "subject": "Test Subject",
+            "conversationId": "conv_abc",
+            "from": {
+                "emailAddress": {
+                    "address": "recipient@example.com",
+                    "name": "Recipient",
+                }
+            },
+            "toRecipients": [
+                {"emailAddress": {"address": "sender@example.com", "name": "Sender"}}
+            ],
+            "ccRecipients": [],
+        }
+
+    def _build_mock_client(self, original_msg: Dict[str, Any]):
+        mock_client = AsyncMock()
+        mock_client.get = AsyncMock(
+            return_value=_make_response(200, original_msg)
+        )
+        mock_client.post = AsyncMock(
+            return_value=_make_response(201, {"id": "reply_draft_id", "categories": []})
+        )
+        mock_client.patch = AsyncMock(
+            return_value=_make_response(200, {})
+        )
+        return mock_client
+
+    @pytest.mark.asyncio
+    async def test_html_reply_uses_comment_then_patch(self):
+        """HTML reply should create draft with empty comment (to preserve the
+        quoted thread) and then PATCH the body with the HTML content."""
+        from dhisana.utils.microsoft365_tools import reply_to_email_m365_async
+
+        ctx = ReplyEmailContext(
+            message_id="msg_123",
+            reply_body=HTML_BODY,
+            sender_email="sender@example.com",
+            sender_name="Sender",
+            reply_body_format=BodyFormat.HTML,
+        )
+        original = self._m365_original_message()
+        mock_client = self._build_mock_client(original)
+
+        mock_cm = AsyncMock()
+        mock_cm.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_cm.__aexit__ = AsyncMock(return_value=False)
+
+        with patch("dhisana.utils.microsoft365_tools.get_microsoft365_access_token", return_value="fake_token"), \
+             patch("dhisana.utils.microsoft365_tools.httpx.AsyncClient", return_value=mock_cm):
+
+            result = await reply_to_email_m365_async(ctx, tool_config=[{"name": "microsoft365"}])
+
+        # 1) The createReply POST should use an empty comment to let Graph
+        #    generate the quoted thread in the draft.
+        post_calls = mock_client.post.call_args_list
+        create_reply_call = [c for c in post_calls if "createReply" in str(c)]
+        assert len(create_reply_call) >= 1
+
+        payload = create_reply_call[0].kwargs.get("json") or create_reply_call[0][1].get("json")
+        assert payload == {"comment": ""}, "HTML reply should create draft with empty comment"
+
+        # 2) A PATCH call should set the HTML body on the draft.
+        patch_calls = mock_client.patch.call_args_list
+        body_patch = [c for c in patch_calls if "body" in json.dumps(c.kwargs.get("json", {}))]
+        assert len(body_patch) >= 1, "Expected a PATCH to set the HTML body on the draft"
+        patch_json = body_patch[0].kwargs.get("json")
+        assert patch_json["body"]["contentType"] == "html"
+        assert HTML_BODY in patch_json["body"]["content"]
+
+    @pytest.mark.asyncio
+    async def test_text_reply_uses_comment(self):
+        """Plain text reply should continue to use the comment field."""
+        from dhisana.utils.microsoft365_tools import reply_to_email_m365_async
+
+        ctx = ReplyEmailContext(
+            message_id="msg_123",
+            reply_body=PLAIN_BODY,
+            sender_email="sender@example.com",
+            sender_name="Sender",
+            reply_body_format=BodyFormat.TEXT,
+        )
+        original = self._m365_original_message()
+        mock_client = self._build_mock_client(original)
+
+        mock_cm = AsyncMock()
+        mock_cm.__aenter__ = AsyncMock(return_value=mock_client)
+        mock_cm.__aexit__ = AsyncMock(return_value=False)
+
+        with patch("dhisana.utils.microsoft365_tools.get_microsoft365_access_token", return_value="fake_token"), \
+             patch("dhisana.utils.microsoft365_tools.httpx.AsyncClient", return_value=mock_cm):
+
+            result = await reply_to_email_m365_async(ctx, tool_config=[{"name": "microsoft365"}])
+
+        post_calls = mock_client.post.call_args_list
+        create_reply_call = [c for c in post_calls if "createReply" in str(c)]
+        assert len(create_reply_call) >= 1
+
+        payload = create_reply_call[0].kwargs.get("json") or create_reply_call[0][1].get("json")
+        assert "comment" in payload
+        assert "message" not in payload