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

dhisana/utils/enrich_lead_information.py

@@ -9,7 +9,6 @@ from typing import Any, Dict, List, Optional
 from urllib.parse import urlparse
 
 from pydantic import BaseModel, Field
-import tldextract
 import mdformat
 
 from dhisana.utils.check_email_validity_tools import process_email_properties
@@ -35,8 +34,9 @@ from dhisana.utils.proxy_curl_tools import (
 from dhisana.utils.research_lead import research_company_with_full_info_ai, research_lead_with_full_info_ai
 from dhisana.utils.serpapi_search_tools import (
     find_organization_linkedin_url_with_google_search,
+    find_user_linkedin_url_by_email_google,
     find_user_linkedin_url_google,
-    get_company_domain_from_google_search,
+    find_user_linkedin_url_with_serper,
     get_company_website_from_linkedin_url,
 )
 
@@ -162,7 +162,7 @@ async def get_clean_lead_info_with_llm(lead_info_str: str, tool_config: Optional
     lead_info, status = await get_structured_output_internal(
         prompt,
         BasicLeadInformation,
-        model="gpt-4.1-mini",
+        model="gpt-5.1-chat",
         tool_config=tool_config
     )
     if status == "ERROR":
@@ -261,16 +261,21 @@ async def validate_and_cleanup(
         or is_invalid_name(first_name)
         or is_invalid_name(last_name)
     ):
-        lead_info_str = str(cloned_properties)
-        logger.info(
-            "Detected invalid name fields. Using LLM to infer/correct name fields."
-        )
-        # Attempt LLM-based cleanup
-        new_lead_info = await get_clean_lead_info_with_llm(lead_info_str, tool_config=tool_config)
-        if new_lead_info:
-            cloned_properties["full_name"] = new_lead_info.get("full_name", "")
-            cloned_properties["first_name"] = new_lead_info.get("first_name", "")
-            cloned_properties["last_name"] = new_lead_info.get("last_name", "")
+        # Check if we have a valid LinkedIn URL - if so, skip LLM as ProxyCurl will fill the data
+        user_linkedin_url = cloned_properties.get("user_linkedin_url", "").strip()
+        if not user_linkedin_url:
+            lead_info_str = str(cloned_properties)
+            logger.info(
+                "Detected invalid name fields. Using LLM to infer/correct name fields."
+            )
+            # Attempt LLM-based cleanup
+            new_lead_info = await get_clean_lead_info_with_llm(lead_info_str, tool_config=tool_config)
+            if new_lead_info:
+                cloned_properties["full_name"] = new_lead_info.get("full_name", "")
+                cloned_properties["first_name"] = new_lead_info.get("first_name", "")
+                cloned_properties["last_name"] = new_lead_info.get("last_name", "")
+        else:
+            logger.info("Valid LinkedIn URL found. Skipping LLM cleanup as ProxyCurl will enrich the data.")
     else:
         # Use the cheaper logic
         cloned_properties = cleanup_user_name(cloned_properties)
@@ -308,12 +313,16 @@ async def enrich_lead_information(
     user_properties: Dict[str, Any],
     use_strict_check: bool = True,
     get_valid_email: bool = True,
+    company_research_instructions: str = "",
+    lead_research_instructions: str = "",
+    enrich_company_information: bool = True,
+    enrich_lead_information: bool = True,
     tool_config: Optional[List[Dict[str, Any]]] = None,
 ) -> Dict[str, Any]:
     logger.debug("Starting enrich_lead_information with user_properties: %s", user_properties)
     cloned_properties = dict(user_properties)
 
-    cloned_properties = await validate_and_cleanup(cloned_properties)
+    cloned_properties = await validate_and_cleanup(cloned_properties, tool_config=tool_config, use_strict_check=use_strict_check)
     
     cloned_properties = await enrich_user_info(
         input_properties=cloned_properties,
@@ -336,29 +345,68 @@ async def enrich_lead_information(
         use_strict_check=use_strict_check,
         tool_config=tool_config,
     )
-    
+
     if get_valid_email:
         await process_email_properties(cloned_properties, tool_config)
-    
-    cloned_properties = await validate_and_cleanup(cloned_properties)
-    cloned_properties["research_summary"] = ""
-    summary = await research_lead_with_full_info_ai(cloned_properties, "", tool_config=tool_config)
-    if summary:
-        cloned_properties["research_summary"] = summary.get("research_summary", "")
-    
-    # Create partial company properties for company research
-    company_company_properties = {
-        "organization_name": cloned_properties.get("organization_name", ""),
-        "primary_domain_of_organization": cloned_properties.get("primary_domain_of_organization", ""),
-        "organization_website": cloned_properties.get("organization_website", "")
-    }
-    company_summary = await research_company_with_full_info_ai(company_company_properties, "", tool_config=tool_config)
-    if company_summary:
-        existing_summary = cloned_properties.get("research_summary", "")
-        markdown_text = existing_summary + "\n\n#### " + company_summary.get("research_summary", "")
-        formatted_markdown = mdformat.text(markdown_text)
-        fixed_markdown = re.sub(r'^(#{1,6})\s+', '##### ', formatted_markdown, flags=re.MULTILINE)
-        cloned_properties["research_summary"] = fixed_markdown
+
+    # ------------------------------------------------------------------
+    # Supplement missing follower count or name information using Serper
+    # ------------------------------------------------------------------
+    linkedin_url = cloned_properties.get("user_linkedin_url", "").strip()
+    follower_count = cloned_properties.get("linkedin_follower_count")
+    first_name = cloned_properties.get("first_name")
+    if (
+        linkedin_url
+        and (follower_count is None or (isinstance(follower_count, str) and not follower_count.strip()) or not first_name)
+    ):
+        serper_result = await find_user_linkedin_url_with_serper(
+            linkedin_url, tool_config=tool_config
+        )
+        if serper_result:
+            if follower_count is None or (
+                isinstance(follower_count, str) and not follower_count.strip()
+            ):
+                cloned_properties["linkedin_follower_count"] = serper_result.get(
+                    "linkedin_follower_count", 0
+                )
+            if not first_name:
+                cloned_properties["first_name"] = serper_result.get("first_name", "")
+                cloned_properties["last_name"] = serper_result.get("last_name", "")
+
+    cloned_properties = await validate_and_cleanup(
+        cloned_properties, tool_config=tool_config, use_strict_check=use_strict_check
+    )
+
+    research_summary = cloned_properties.get("research_summary", "")
+
+    if enrich_lead_information:
+        summary = await research_lead_with_full_info_ai(
+            cloned_properties, lead_research_instructions, tool_config=tool_config
+        )
+        if summary:
+            research_summary = summary.get("research_summary", "")
+
+    if enrich_company_information:
+        company_company_properties = {
+            "organization_name": cloned_properties.get("organization_name", ""),
+            "primary_domain_of_organization": cloned_properties.get("primary_domain_of_organization", ""),
+            "organization_website": cloned_properties.get("organization_website", ""),
+        }
+        company_summary = await research_company_with_full_info_ai(
+            company_company_properties,
+            company_research_instructions,
+            tool_config=tool_config,
+        )
+        if company_summary:
+            markdown_text = research_summary + "\n\n#### " + company_summary.get(
+                "research_summary", ""
+            )
+            formatted_markdown = mdformat.text(markdown_text)
+            research_summary = re.sub(
+                r'^(#{1,6})\s+', '##### ', formatted_markdown, flags=re.MULTILINE
+            )
+
+    cloned_properties["research_summary"] = research_summary
     return cloned_properties
 
 
@@ -374,6 +422,34 @@ class UserInfoFromGithubProfileId(BaseModel):
     location: str
 
 
+def extract_id_from_salesnav_url(url_key: str) -> str:
+    """
+    Extract the Sales Navigator lead ID from a URL like
+    'https://www.linkedin.com/sales/lead/<ID>?...'
+    """
+    if not url_key:
+        return ""
+    match = re.search(r"linkedin\.com/sales/lead/([^/?#,]+)", url_key, re.IGNORECASE)
+    if not match:
+        return ""
+    # strip out any non-word or hyphen chars
+    return re.sub(r"[^\w-]", "", match.group(1))
+
+def proxy_linkedin_url(user_linkedin_salesnav_url: str) -> str:
+    """
+    Given a Sales Navigator URL, return the corresponding public LinkedIn URL.
+    Raises ValueError if the ID cannot be extracted.
+    """
+    salesnav_id = extract_id_from_salesnav_url(user_linkedin_salesnav_url)
+    if not salesnav_id:
+        raise ValueError("Could not extract ID from Sales Nav URL.")
+    return f"https://www.linkedin.com/in/{salesnav_id}"
+
+# -------------------------------------------------------------------
+# (Pseudo) get_structured_output_internal, find_user_linkedin_url_google
+# and other references assumed to exist in your environment.
+# -------------------------------------------------------------------
+
 async def get_user_linkedin_url_from_github_profile(
     github_profile_id: str,
     lead_properties: dict, 
@@ -384,7 +460,6 @@ async def get_user_linkedin_url_from_github_profile(
     Attempt to locate a user's LinkedIn profile URL from their GitHub profile ID via web search.
     Also gather basic user info (first/last name) if possible.
     """
-
     instructions = f"""
         Give user information from user GitHub handle; try to locate the LinkedIn profile URL
         for the user using web search.
@@ -414,10 +489,11 @@ async def get_user_linkedin_url_from_github_profile(
         }}
     """
 
+    # Example call to structured output function
     response, status = await get_structured_output_internal(
         instructions, 
         UserInfoFromGithubProfileId, 
-        model="gpt-4.1-mini", 
+        model="gpt-5.1-chat", 
         use_web_search=True,
         tool_config=tool_config
     )
@@ -426,26 +502,23 @@ async def get_user_linkedin_url_from_github_profile(
     else:
         return {}
 
-
 async def enrich_user_info(
     input_properties: Dict[str, Any],
     use_strict_check: bool,
     tool_config: Optional[List[Dict[str, Any]]] = None,
 ) -> Dict[str, Any]:
     """
-    Attempt to find or fix a user's LinkedIn URL using name, title, location, company info
-    or GitHub profile handle if present.
-
-    :param input_properties: Dictionary containing user/lead details.
-    :param use_strict_check: Whether to use strict matching during searches.
-    :param tool_config: Optional list of tool configurations dicts.
-    :return: Updated dictionary with user LinkedIn URL if found.
+    Attempt to find or fix a user's LinkedIn URL using name, title, location, 
+    company info or GitHub profile handle if present. If still not found, 
+    but user_linkedin_salesnav_url exists, we fall back to creating a 
+    proxy URL from the Sales Navigator link.
     """
     logger.debug("Starting enrich_user_info for: %s", input_properties.get("full_name"))
     user_linkedin_url = (input_properties.get("user_linkedin_url") or "").strip()
     input_properties["linkedin_url_match"] = False
     github_profile_id = (input_properties.get("github_profile_id") or "").strip()
 
+    # 1) If we do not have a user_linkedin_url, try getting it from GitHub
     if not user_linkedin_url:
         if github_profile_id:
             response = await get_user_linkedin_url_from_github_profile(
@@ -467,7 +540,7 @@ async def enrich_user_info(
                     input_properties["lead_location"] = response.get("location", "")
                 return input_properties
 
-        # If still no LinkedIn URL, try using name, title, location, company...
+        # 2) If still no LinkedIn URL, try name/title/org searching
         full_name = (input_properties.get("full_name") or "").strip()
         if not full_name:
             first_name = (input_properties.get("first_name", "") or "").strip()
@@ -478,9 +551,11 @@ async def enrich_user_info(
         location = input_properties.get("lead_location", "") or ""
         org_name = (input_properties.get("organization_name", "") or "").strip()
         org_domain = (input_properties.get("primary_domain_of_organization", "") or "").strip()
+        email = (input_properties.get("email") or "").strip()
 
         if full_name and (org_name or org_domain or title):
-            user_linkedin_url = await find_user_linkedin_url_google(
+            # This function does a google-based search for the user's LinkedIn
+            found_linkedin_url = await find_user_linkedin_url_google(
                 user_name=full_name,
                 user_title=title,
                 user_location=location,
@@ -489,11 +564,50 @@ async def enrich_user_info(
                 use_strict_check=use_strict_check,
                 tool_config=tool_config,
             )
-            input_properties["user_linkedin_url"] = user_linkedin_url
+            if found_linkedin_url:
+                user_linkedin_url = found_linkedin_url
+                input_properties["user_linkedin_url"] = user_linkedin_url
+        if not user_linkedin_url and email:
+            # If we have an email but no name, try searching by email
+            email_lookup_result = await find_user_linkedin_url_by_email_google(
+                email=email,
+                user_name=full_name,
+                user_title=title,
+                user_location=location,
+                user_company=org_name,
+                tool_config=tool_config,
+            )
+            if email_lookup_result and email_lookup_result.get("linkedin_url"):
+                user_linkedin_url = email_lookup_result["linkedin_url"]
+                input_properties["user_linkedin_url"] = user_linkedin_url
+                confidence = email_lookup_result.get("confidence", 0.0)
+                reasoning = email_lookup_result.get("reasoning", "")
+                input_properties["user_linkedin_url_confidence"] = confidence
+                input_properties["user_linkedin_url_reasoning"] = reasoning
+
+                additional_properties = input_properties.get("additional_properties") or {}
+                additional_properties["user_linkedin_url_confidence"] = confidence
+                if reasoning:
+                    additional_properties["user_linkedin_url_reasoning"] = reasoning
+                input_properties["additional_properties"] = additional_properties
+
+        # 3) Final fallback: if STILL no user_linkedin_url, 
+        #    but user_linkedin_salesnav_url is present, use proxy
+        if not input_properties.get("user_linkedin_url"):
+            salesnav_url = input_properties.get("user_linkedin_salesnav_url", "")
+            if salesnav_url:
+                try:
+                    proxy_url = proxy_linkedin_url(salesnav_url)
+                    input_properties["user_linkedin_url"] = proxy_url
+                    logger.debug("Falling back to proxy LinkedIn URL from SalesNav: %s", proxy_url)
+                except ValueError:
+                    # If we can't parse an ID from the sales nav URL, skip
+                    logger.warning("Could not parse ID from user_linkedin_salesnav_url: %s", salesnav_url)
 
     return input_properties
 
 
+
 async def enrich_with_provider(
     cloned_properties: Dict[str, Any],
     tool_config: Optional[List[Dict[str, Any]]],
@@ -651,16 +765,32 @@ async def enrich_organization_info_from_company_url(
     organization_linkedin_url: str,
     use_strict_check: bool = True,
     tool_config: Optional[List[Dict[str, Any]]] = None,
+    categories: Optional[bool] = None,
+    funding_data: Optional[bool] = None,
+    exit_data: Optional[bool] = None,
+    acquisitions: Optional[bool] = None,
+    extra: Optional[bool] = None,
+    use_cache: Optional[str] = "if-present",
+    fallback_to_cache: Optional[str] = "on-error",
 ) -> Dict[str, Any]:
     """
     Given an organization LinkedIn URL, attempt to enrich its data (e.g. name, website)
-    via ProxyCurl. If data is found, set domain, then return the dict. Otherwise, return {}.
+    via ProxyCurl. Additional Proxycurl Company API boolean flags (categories, funding_data, etc.)
+    can be supplied to control the returned payload (True -> "include"). If data is found,
+    set domain, then return the dict. Otherwise, return {}.
     """
 
     # Call ProxyCurl to enrich
     company_data = await enrich_organization_info_from_proxycurl(
         organization_linkedin_url=organization_linkedin_url,
-        tool_config=tool_config
+        tool_config=tool_config,
+        categories=categories,
+        funding_data=funding_data,
+        exit_data=exit_data,
+        acquisitions=acquisitions,
+        extra=extra,
+        use_cache=use_cache,
+        fallback_to_cache=fallback_to_cache,
     )
 
     # If ProxyCurl returned any data, set domain, then return
@@ -698,7 +828,7 @@ async def enrich_organization_info_from_job_url(
         job_info = await enrich_job_info_from_proxycurl(
             normalized_job_url, tool_config=tool_config
         )
-    except Exception as e:
+    except Exception:
         logger.exception("Exception occurred while fetching job info from Proxycurl.")
         return {}
 
@@ -789,7 +919,7 @@ async def get_company_domain_from_llm_web_search(
         response, status = await get_structured_output_internal(
             instructions,
             CompanyInfoFromName,
-            model="gpt-4.1-mini",
+            model="gpt-5.1-chat",
             use_web_search=True,
             tool_config=tool_config
         )
@@ -798,6 +928,6 @@ async def get_company_domain_from_llm_web_search(
             return response.model_dump()
         else:
             return {}
-    except Exception as e:
+    except Exception:
         logger.exception("Exception during get_company_domain_from_llm_web_search.")
         return {}

dhisana/utils/fetch_openai_config.py

@@ -0,0 +1,129 @@
+"""
+Unified OpenAI / Azure OpenAI helper (no env-fallback for secrets)
+=================================================================
+
+Resolution order
+----------------
+1. If `tool_config` has a **"openai"** block  → public OpenAI
+2. Else if it has an **"azure_openai"** block → Azure OpenAI
+3. Otherwise                            → raise ValueError
+
+`api_key` **and** `endpoint` (for Azure) must therefore be supplied in
+`tool_config`.  They will never be read from the host environment.
+
+Optional:
+  • `AZURE_OPENAI_API_VERSION` – defaults to 2025-03-01-preview
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Dict, List, Optional, Tuple, Union
+
+from openai import AsyncOpenAI, OpenAI, AzureOpenAI, AsyncAzureOpenAI
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 1. Helpers: config parsing
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _extract_config(
+    tool_config: Optional[List[Dict]], provider_name: str
+) -> Dict[str, str]:
+    """Return the config map for the requested provider name, else {}."""
+    if not tool_config:
+        return {}
+    block = next((b for b in tool_config if b.get("name") == provider_name), {})
+    return {entry["name"]: entry["value"] for entry in block.get("configuration", []) if entry}
+
+
+def _discover_credentials(
+    tool_config: Optional[List[Dict]] = None,
+) -> Tuple[str, str, Optional[str]]:
+    """
+    Return (provider, api_key, endpoint_or_None).
+
+    provider ∈ {"public", "azure"}
+    """
+    # 1️⃣ Public OpenAI
+    openai_cfg = _extract_config(tool_config, "openai")
+    if openai_cfg:
+        key = openai_cfg.get("apiKey")
+        if not key:
+            raise ValueError(
+                "OpenAI integration is not configured. Please configure the connection to OpenAI in Integrations."
+            )
+        return "public", key, None
+
+    # 2️⃣ Azure OpenAI
+    azure_cfg = _extract_config(tool_config, "azure_openai")
+    if azure_cfg:
+        key = azure_cfg.get("apiKey")
+        endpoint = azure_cfg.get("endpoint")
+        if not key or not endpoint:
+            raise ValueError(
+                "Azure OpenAI integration is not configured. Please configure the connection to Azure OpenAI in Integrations."
+            )
+        return "azure", key, endpoint
+
+    # 3️⃣ Neither block present → error
+    raise ValueError(
+        "OpenAI integration is not configured. Please configure the connection to OpenAI in Integrations."
+    )
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 2. Client factories
+# ─────────────────────────────────────────────────────────────────────────────
+
+def _api_version() -> str:
+    """Return the Azure API version (env-controlled, no secret)."""
+    return os.getenv("AZURE_OPENAI_API_VERSION", "2025-03-01-preview")
+
+
+def create_openai_client(
+    tool_config: Optional[List[Dict]] = None,
+) -> Union[OpenAI, AzureOpenAI]:
+    """
+    Return a *synchronous* client:
+        • openai.OpenAI      – public service
+        • openai.AzureOpenAI – Azure
+    """
+    provider, key, endpoint = _discover_credentials(tool_config)
+
+    if provider == "public":
+        return OpenAI(api_key=key)
+
+    # Azure
+    return AzureOpenAI(api_key=key, azure_endpoint=endpoint, api_version=_api_version())
+
+
+def create_async_openai_client(
+    tool_config: Optional[List[Dict]] = None,
+) -> AsyncOpenAI:
+    """
+    Return an *async* client (AsyncOpenAI).
+
+    For Azure we pass both `azure_endpoint` and `api_version`.
+    """
+    provider, key, endpoint = _discover_credentials(tool_config)
+
+    if provider == "public":
+        return AsyncOpenAI(api_key=key)
+
+    return AsyncAzureOpenAI(
+        api_key=key,
+        azure_endpoint=endpoint,
+        api_version=_api_version(),
+    )
+
+
+
+# ─────────────────────────────────────────────────────────────────────────────
+# 3. Convenience helper (legacy)
+# ─────────────────────────────────────────────────────────────────────────────
+
+def get_openai_access_token(tool_config: Optional[List[Dict]] = None) -> str:
+    """Return just the API key (legacy helper)."""
+    _, key, _ = _discover_credentials(tool_config)
+    return key

dhisana/utils/field_validators.py

@@ -1,5 +1,5 @@
 import logging
-from urllib.parse import urlparse, urlunparse
+from urllib.parse import urlparse
 import urllib.parse
 import re
 

dhisana/utils/g2_tools.py

@@ -1,5 +1,4 @@
 import asyncio
-import json
 import logging
 import os
 from typing import Optional

dhisana/utils/generate_content.py

@@ -1,4 +1,3 @@
-from enum import Enum
 from typing import Dict, List, Optional
 from dhisana.schemas.sales import ChannelType, ContentGenerationContext
 from dhisana.utils.generate_email_response import generate_inbound_email_response_variations