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

dhisana/utils/built_with_api_tools.py

@@ -23,7 +23,7 @@ def get_builtwith_api_key(tool_config: Optional[List[Dict]] = None) -> str:
         str: The BUILTWITH_API_KEY access token.
 
     Raises:
-        ValueError: If the access token is not found in the tool configuration or environment variable.
+        ValueError: If the BuiltWith integration has not been configured.
     """
     if tool_config:
         builtwith_config = next(
@@ -43,7 +43,9 @@ def get_builtwith_api_key(tool_config: Optional[List[Dict]] = None) -> str:
 
     BUILTWITH_API_KEY = BUILTWITH_API_KEY or os.getenv("BUILTWITH_API_KEY")
     if not BUILTWITH_API_KEY:
-        raise ValueError("BUILTWITH_API_KEY access token not found in tool_config or environment variable")
+        raise ValueError(
+            "BuiltWith integration is not configured. Please configure the connection to BuiltWith in Integrations."
+        )
     return BUILTWITH_API_KEY
 
 # Use BuiltWith API to find tech stack and financials of a company

dhisana/utils/check_email_validity_tools.py

@@ -31,7 +31,6 @@ import aiohttp
 # ────────────────────────────────────────────────────────────────────────────
 from dhisana.schemas.sales import HubSpotLeadInformation
 from dhisana.utils.field_validators import validate_and_clean_email
-from dhisana.utils.hubspot_crm_tools import lookup_contact_by_name_and_domain
 from dhisana.utils.apollo_tools import enrich_user_info_with_apollo
 from dhisana.utils.assistant_tool_tag import assistant_tool
 from dhisana.utils.cache_output_tools import cache_output, retrieve_output
@@ -71,7 +70,9 @@ def get_findymail_access_token(tool_config: Optional[List[Dict]] = None) -> str:
 
     api_key = api_key or os.getenv("FINDYMAIL_API_KEY")
     if not api_key:
-        logger.warning("FINDYMAIL_API_KEY not found in config or env.")
+        logger.warning(
+            "Findymail integration is not configured. Please configure the connection to Findymail in Integrations."
+        )
         return ""
     return api_key
 
@@ -99,7 +100,9 @@ def get_zero_bounce_access_token(tool_config: Optional[List[Dict]] = None) -> st
 
     api_key = api_key or os.getenv("ZERO_BOUNCE_API_KEY")
     if not api_key:
-        logger.warning("ZERO_BOUNCE_API_KEY not found in config or env.")
+        logger.warning(
+            "ZeroBounce integration is not configured. Please configure the connection to ZeroBounce in Integrations."
+        )
         return ""
     return api_key
 
@@ -122,7 +125,9 @@ def get_hunter_access_token(tool_config: Optional[List[Dict]] = None) -> str:
 
     api_key = api_key or os.getenv("HUNTER_API_KEY")
     if not api_key:
-        logger.warning("HUNTER_API_KEY not found in config or env.")
+        logger.warning(
+            "Hunter integration is not configured. Please configure the connection to Hunter in Integrations."
+        )
         return ""
     return api_key
 
@@ -304,46 +309,58 @@ async def guess_email_with_findymail(
     first_name: str,
     last_name: str,
     domain: str,
-    user_linkedin_url: Optional[str] = None,  # Unused by FM
+    user_linkedin_url: Optional[str] = None,
     middle_name: Optional[str] = None,
     tool_config: Optional[List[Dict]] = None,
 ) -> Dict[str, Any]:
-    """
-    Use Findymail `/search/name`. Returns only verified emails → high confidence.
+    """Use Findymail to guess an email.
+
+    If ``user_linkedin_url`` is provided, the function queries ``/search/linkedin``.
+    Otherwise it falls back to ``/search/name`` with ``first_name``/``last_name``
+    and ``domain``. Only verified emails are returned and therefore considered
+    high confidence.
     """
     logger.info("Entering guess_email_with_findymail")
-    if not first_name or not last_name or not domain:
-        return {"email": "", "email_confidence": "low"}
+
+    if user_linkedin_url:
+        cache_key = f"findymail:{user_linkedin_url}"
+    else:
+        if not first_name or not last_name or not domain:
+            return {"email": "", "email_confidence": "low"}
+        cache_key = f"findymail:{first_name}_{last_name}_{domain}"
 
     api_key = get_findymail_access_token(tool_config)
     if not api_key:
         return {"email": "", "email_confidence": "low"}
 
-    cache_key = f"findymail:{first_name}_{last_name}_{domain}"
     cached = retrieve_output("findymail_guess", cache_key)
     if cached:
         return json.loads(cached[0])
 
-    url = f"{FINDYMAIL_BASE_URL}/search/name"
+    if user_linkedin_url:
+        url = f"{FINDYMAIL_BASE_URL}/search/linkedin"
+        payload = {"linkedin_url": user_linkedin_url, "webhook_url": None}
+    else:
+        url = f"{FINDYMAIL_BASE_URL}/search/name"
+        full_name = " ".join(filter(None, [first_name, middle_name, last_name]))
+        payload = {"name": full_name, "domain": domain}
+
     headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
-    full_name = " ".join(filter(None, [first_name, middle_name, last_name]))
 
     try:
         async with aiohttp.ClientSession() as session:
-            async with session.post(
-                url, headers=headers, json={"name": full_name, "domain": domain}
-            ) as r:
+            async with session.post(url, headers=headers, json=payload) as r:
                 if r.status != 200:
-                    logger.warning("[Findymail] search/name non‑200: %s", r.status)
+                    logger.warning("[Findymail] search non‑200: %s", r.status)
                     result = {"email": "", "email_confidence": "low"}
                 else:
                     data = await r.json()
-                    contact = data.get('contact', None)
+                    contact = data.get("contact")
                     found = contact.get("email", "") if contact else ""
                     if found:
                         result = {
                             "email": found,
-                            "email_confidence": "high" if found else "low",
+                            "email_confidence": "high",
                             "contact_info": json.dumps(contact) if contact else "",
                         }
                     else:

dhisana/utils/check_for_intent_signal.py

@@ -5,7 +5,6 @@ from typing import Any, Dict, List, Optional, cast
 from pydantic import BaseModel
 from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
 from dhisana.utils.compose_search_query import (
-    generate_google_search_queries,
     get_search_results_for_insights
 )
 
@@ -49,7 +48,7 @@ async def check_for_intent_signal(
             logger.info("Search query: %s", query_str)
             logger.info("Search results snippet: %s", results_str[:100])  # Show partial snippet
             search_results_text += f"Query: {query_str}\nResults: {results_str}\n\n"
-    current_date_iso = datetime.datetime.now().isoformat()
+    datetime.datetime.now().isoformat()
     user_prompt = f"""
     Hi AI Assistant,
     You are an expert in scoring leads based on intent signals.

dhisana/utils/check_linkedin_url_validity.py

@@ -1,6 +1,5 @@
-import os
+import re
 from typing import Dict, List, Optional, Any
-import aiohttp
 from pydantic import BaseModel
 from dhisana.utils.apollo_tools import enrich_person_info_from_apollo
 from dhisana.utils.assistant_tool_tag import assistant_tool
@@ -28,6 +27,7 @@ def compare_field(
     person_key: str
 ) -> bool:
     if not lead_properties.get(lead_key):
+        # If the lead doesn't have the field at all, let's consider it "matched" by default
         return True
 
     lead_value = lead_properties.get(lead_key, "")
@@ -72,8 +72,7 @@ async def validate_linkedin_url_with_apollo(
         linkedin_url=linkedin_url, 
         tool_config=tool_config
     )
-    # If no data is returned from Apollo, return defaults (all False except
-    # the logic in compare_field where no input -> True).
+    # If no data is returned from Apollo, return defaults
     if not linkedin_data:
         return match_result.model_dump()
 
@@ -120,8 +119,7 @@ async def validate_linkedin_url_with_proxy_curl(
         linkedin_url=linkedin_url, 
         tool_config=tool_config
     )
-    # If no data is returned from Apollo, return defaults (all False except
-    # the logic in compare_field where no input -> True).
+    # If no data is returned from Proxycurl, return defaults
     if not linkedin_data:
         return match_result.model_dump()
 
@@ -148,6 +146,18 @@ LINKEDIN_VALIDATE_TOOL_NAME_TO_FUNCTION_MAP = {
     "proxycurl": validate_linkedin_url_with_proxy_curl
 }
 
+def is_proxy_linkedin_url(url: str) -> bool:
+    """
+    Determines if a LinkedIn URL is "proxy-like": 
+    specifically, if /in/<profile_id> starts with 'acw' and is > 10 chars total.
+    """
+    match = re.search(r"linkedin\.com/in/([^/]+)", url, re.IGNORECASE)
+    if match:
+        profile_id = match.group(1).strip()
+        if profile_id.startswith("acw") and len(profile_id) > 10:
+            return True
+    return False
+
 @assistant_tool
 async def check_linkedin_url_validity(
     lead_properties: Dict[str, Any],
@@ -155,10 +165,12 @@ async def check_linkedin_url_validity(
 ) -> Dict[str, bool]:
     """
     Validates LinkedIn URL (and related fields) by choosing the appropriate tool
-    from the tool_config.
+    from the tool_config. If the LinkedIn URL is detected as a "proxy" URL,
+    we skip calling any external tool and directly return 'linkedin_url_valid' = True.
 
     Args:
-        lead_properties (dict): Lead info (e.g. first_name, last_name, job_title, lead_location, user_linkedin_url).
+        lead_properties (dict): Lead info (e.g. first_name, last_name, job_title, 
+                                lead_location, user_linkedin_url).
         tool_config (Optional[List[Dict]]): Configuration to identify which tool is available.
 
     Returns:
@@ -170,6 +182,20 @@ async def check_linkedin_url_validity(
     if not tool_config:
         raise ValueError("No tool configuration found.")
 
+    # ---------------------------------------------------------
+    # 1) If it’s a "proxy" LinkedIn URL, just return valid = True
+    # ---------------------------------------------------------
+    linkedin_url = lead_properties.get("user_linkedin_url", "")
+    if is_proxy_linkedin_url(linkedin_url):
+        match_result = LeadLinkedInMatch()
+        match_result.linkedin_url_valid = True
+        # The other fields remain their default (False) unless
+        # you want to set them otherwise. For now, we just do:
+        return match_result.model_dump()
+
+    # ---------------------------------------------------------
+    # 2) Otherwise, pick the correct tool and validate normally
+    # ---------------------------------------------------------
     chosen_tool_func = None
     for item in tool_config:
         tool_name = item.get("name")

dhisana/utils/clay_tools.py

@@ -1,4 +1,3 @@
-import asyncio
 import aiohttp
 import logging
 from typing import Optional
@@ -22,7 +21,9 @@ async def push_to_clay_table(
     - **dict**: Response message or error.
     """
     if not api_key:
-        return {'error': "API key not provided"}
+        return {
+            'error': "Clay integration is not configured. Please configure the connection to Clay in Integrations."
+        }
 
     if not webhook:
         return {'error': "Webhook URL not provided"}

dhisana/utils/clean_properties.py

@@ -1,11 +1,8 @@
-from typing import Any, Dict, List, Union
+from typing import Any, Dict, List
 import copy
 from typing import Any, Dict, List, Optional
 
-from pydantic import BaseModel, Field
 
-from dhisana.schemas.sales import HubSpotLeadInformation
-from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
 
 def remove_empty(data: Any) -> Any:
     """

dhisana/utils/compose_salesnav_query.py

@@ -1,5 +1,4 @@
 import logging
-import os
 from typing import Any, Dict, List, Optional
 
 import openai  # Remove if not required outside get_structured_output_internal

dhisana/utils/compose_search_query.py

@@ -1,4 +1,3 @@
-import datetime
 import logging
 import os
 import json
@@ -352,8 +351,11 @@ async def get_search_results_for_insights(
 
 def get_serp_api_access_token(tool_config: Optional[List[Dict]] = None) -> str:
     """
-    Retrieves the SERPAPI_KEY access token from the provided tool configuration 
+    Retrieves the SERPAPI_KEY access token from the provided tool configuration
     or from the environment variable SERPAPI_KEY.
+
+    Raises:
+        ValueError: If the SerpAPI integration has not been configured.
     """
     serpapi_key = None
     if tool_config:
@@ -373,7 +375,7 @@ def get_serp_api_access_token(tool_config: Optional[List[Dict]] = None) -> str:
     serpapi_key = serpapi_key or os.getenv("SERPAPI_KEY")
     if not serpapi_key:
         raise ValueError(
-            "SERPAPI_KEY access token not found in tool_config or environment variable."
+            "SerpAPI integration is not configured. Please configure the connection to SerpAPI in Integrations."
         )
     return serpapi_key
 
@@ -470,6 +472,7 @@ Output must be valid JSON, e.g.:
         prompt=prompt,
         response_format=TechnologyUsedCheck,
         effort="high",
+        model="gpt-5.1-chat",
         tool_config=tool_config
     )
 
@@ -531,6 +534,7 @@ Output must be valid JSON, e.g.:
         prompt=prompt,
         response_format=TechnologyAndRoleCheck,
         effort="high",
+        model="gpt-5.1-chat",
         tool_config=tool_config
     )
 

dhisana/utils/composite_tools.py

@@ -7,7 +7,6 @@ from dhisana.utils.built_with_api_tools import (
 )
 from dhisana.utils.dataframe_tools import get_structured_output
 from dhisana.utils.google_custom_search import search_google_custom
-from dhisana.utils.serpapi_search_tools import search_google
 
 
 class QualifyCompanyBasedOnTechUsage(BaseModel):

dhisana/utils/dataframe_tools.py

@@ -33,13 +33,13 @@ class PandasQuery(BaseModel):
     
 
 @assistant_tool   
-async def get_structured_output(message: str, response_type, model: str = "o3-mini"):
+async def get_structured_output(message: str, response_type, model: str = "gpt-5.1-chat"):
     """
     Asynchronously retrieves structured output from the OpenAI API based on the input message.
 
     :param message: The input message to be processed by the OpenAI API.
     :param response_type: The expected format of the response (e.g., JSON).
-    :param model: The model to be used for processing the input message. Defaults to "o3-mini".
+    :param model: The model to be used for processing the input message. Defaults to "gpt-5.1-chat".
     :return: A tuple containing the parsed response and a status string ('SUCCESS' or 'FAIL').
     """
     try:

dhisana/utils/email_body_utils.py

@@ -0,0 +1,72 @@
+"""Small helpers for handling e-mail bodies across providers."""
+
+from typing import Optional, Tuple
+import html as html_lib
+import re
+
+
+def looks_like_html(text: str) -> bool:
+    """Heuristically determine whether the body contains HTML markup."""
+    return bool(text and re.search(r"<[a-zA-Z][^>]*>", text))
+
+
+def _normalize_format_hint(format_hint: Optional[str]) -> str:
+    """
+    Normalize a user-supplied format hint into html/text/auto.
+
+    Accepts variations like "plain" or "plaintext" as text.
+    """
+    if not format_hint:
+        return "auto"
+    fmt_raw = getattr(format_hint, "value", format_hint)
+    fmt = str(fmt_raw).strip().lower()
+    if fmt in ("html",):
+        return "html"
+    if fmt in ("text", "plain", "plain_text", "plaintext"):
+        return "text"
+    return "auto"
+
+
+def html_to_plain_text(html: str) -> str:
+    """
+    Produce a very lightweight plain-text version of an HTML fragment.
+    This keeps newlines on block boundaries and strips tags.
+    """
+    if not html:
+        return ""
+    text = re.sub(r"(?is)<(script|style).*?>.*?</\1>", " ", html)
+    text = re.sub(r"(?i)<br\s*/?>", "\n", text)
+    text = re.sub(r"(?i)</(p|div|li|h[1-6])\s*>", "\n", text)
+    text = re.sub(r"(?is)<.*?>", "", text)
+    text = html_lib.unescape(text)
+    text = re.sub(r"\s+\n", "\n", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+
+def plain_text_to_html(text: str) -> str:
+    """Wrap plain text in a minimal HTML container that preserves newlines."""
+    if text is None:
+        return ""
+    escaped = html_lib.escape(text)
+    return f'<div style="white-space: pre-wrap">{escaped}</div>'
+
+
+def body_variants(body: Optional[str], format_hint: Optional[str]) -> Tuple[str, str, str]:
+    """
+    Return (plain, html, resolved_format) honoring an optional format hint.
+
+    resolved_format is "html" or "text" after applying auto-detection.
+    """
+    content = body or ""
+    fmt = _normalize_format_hint(format_hint)
+
+    if fmt == "html":
+        return html_to_plain_text(content), content, "html"
+    if fmt == "text":
+        return content, plain_text_to_html(content), "text"
+
+    if looks_like_html(content):
+        return html_to_plain_text(content), content, "html"
+
+    return content, plain_text_to_html(content), "text"