dhisana 0.0.1.dev213__tar.gz → 0.0.1.dev214__tar.gz

{dhisana-0.0.1.dev213 → dhisana-0.0.1.dev214}/PKG-INFO

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

{dhisana-0.0.1.dev213 → dhisana-0.0.1.dev214}/setup.py

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

{dhisana-0.0.1.dev213 → dhisana-0.0.1.dev214}/src/dhisana/utils/enrich_lead_information.py

@@ -34,6 +34,7 @@ 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,
     find_user_linkedin_url_with_serper,
     get_company_website_from_linkedin_url,
@@ -550,6 +551,7 @@ 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):
             # This function does a google-based search for the user's LinkedIn
@@ -565,6 +567,29 @@ async def enrich_user_info(
             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

{dhisana-0.0.1.dev213 → dhisana-0.0.1.dev214}/src/dhisana/utils/proxy_curl_tools.py

@@ -361,9 +361,20 @@ async def enrich_organization_info_from_proxycurl(
                         logger.warning(msg)
                         await asyncio.sleep(30)
                         return {"error": msg}
+                    elif response.status == 404:
+                        error_text = await response.text()
+                        logger.warning(
+                            f"Proxycurl organization profile not found for LinkedIn URL {standardized_url}: {error_text}"
+                        )
+                        cache_output(
+                            "enrich_organization_info_from_proxycurl", standardized_url, {}
+                        )
+                        return {}
                     else:
                         error_text = await response.text()
-                        logger.error(f"Error from Proxycurl organization info fetch by URL: {error_text}")
+                        logger.error(
+                            f"Error from Proxycurl organization info fetch by URL: {error_text}"
+                        )
                         return {}
             except Exception as e:
                 logger.exception("Exception occurred while fetching organization info from Proxycurl by LinkedIn URL.")

{dhisana-0.0.1.dev213 → dhisana-0.0.1.dev214}/src/dhisana/utils/serpapi_search_tools.py

@@ -1,6 +1,6 @@
 import json
 import re
-from typing import Dict, List, Optional
+from typing import Any, Dict, List, Optional, Set
 from urllib.parse import urlparse
 import urllib.parse
 import aiohttp
@@ -35,6 +35,12 @@ class LeadSearchResult(BaseModel):
     user_linkedin_url: str = ""
 
 
+class LinkedinCandidateChoice(BaseModel):
+    chosen_link: str = ""
+    confidence: float = 0.0
+    reasoning: str = ""
+
+
 async def get_structured_output(text: str, tool_config: Optional[List[Dict]] = None) -> LeadSearchResult:
     """Parse text snippet into ``LeadSearchResult`` using OpenAI."""
 
@@ -82,6 +88,65 @@ async def find_user_linkedin_url_with_serper(
     return None
 
 
+async def pick_best_linkedin_candidate_with_llm(
+    email: str,
+    user_name: str,
+    user_title: str,
+    user_location: str,
+    user_company: str,
+    candidates: List[Dict],
+    tool_config: Optional[List[Dict]] = None,
+) -> Optional[LinkedinCandidateChoice]:
+    """Ask the LLM to assess candidate LinkedIn URLs and pick the best match."""
+
+    if not candidates:
+        return None
+
+    candidates_sorted = candidates[-3:]
+    candidate_lines = []
+    for idx, candidate in enumerate(candidates_sorted, start=1):
+        candidate_lines.append(
+            "\n".join(
+                [
+                    f"Candidate {idx}:",
+                    f"  Link: {candidate.get('link', '')}",
+                    f"  Title: {candidate.get('title', '')}",
+                    f"  Snippet: {candidate.get('snippet', '')}",
+                    f"  Subtitle: {candidate.get('subtitle', '')}",
+                    f"  Query: {candidate.get('query', '')}",
+                ]
+            )
+        )
+
+    prompt = (
+        "You are validating LinkedIn profile matches for a lead enrichment workflow.\n"
+        "Given the lead context and candidate search results, pick the most likely LinkedIn profile.\n"
+        "If no candidate seems appropriate, return an empty link and confidence 0.\n"
+        "Consider whether the email, name, company, title, or location aligns with the candidate.\n"
+        "Lead context:\n"
+        f"- Email: {email or 'unknown'}\n"
+        f"- Name: {user_name or 'unknown'}\n"
+        f"- Title: {user_title or 'unknown'}\n"
+        f"- Company: {user_company or 'unknown'}\n"
+        f"- Location: {user_location or 'unknown'}\n\n"
+        "Candidates:\n"
+        f"{chr(10).join(candidate_lines)}\n\n"
+        "Return JSON with fields: chosen_link (string), confidence (0-1 float), reasoning (short string)."
+    )
+
+    result, status = await get_structured_output_internal(
+        prompt,
+        LinkedinCandidateChoice,
+        model="gpt-4.1-mini",
+        tool_config=tool_config,
+    )
+
+    if status != "SUCCESS" or result is None:
+        return None
+
+    return result
+
+
 @assistant_tool
 async def get_company_domain_from_google_search(
     company_name: str,
@@ -304,6 +369,221 @@ async def find_user_linkedin_url_google(
     return ""
 
 
+@assistant_tool
+async def find_user_linkedin_url_by_email_google(
+    email: str,
+    user_name: str = "",
+    user_title: str = "",
+    user_location: str = "",
+    user_company: str = "",
+    tool_config: Optional[List[Dict]] = None,
+) -> Optional[Dict[str, Any]]:
+    """
+    Find the LinkedIn URL for a user based primarily on their email address.
+
+    Additional profile hints (name, title, location, company) improve query precision
+    when supplied. Returns a dict with the best LinkedIn URL, LLM confidence score,
+    and short reasoning when a match clears the confidence threshold; otherwise ``None``.
+    """
+    logger.info("Entering find_user_linkedin_url_by_email_google")
+
+    if not email:
+        logger.warning("No email provided.")
+        return None
+
+    normalized_email = email.strip().lower()
+    email_local_part = normalized_email.split("@")[0] if "@" in normalized_email else normalized_email
+    email_local_humanized = re.sub(r"[._-]+", " ", email_local_part).strip()
+
+    queries: List[str] = []
+
+    def add_query(query: str) -> None:
+        query = query.strip()
+        if query and query not in queries:
+            queries.append(query)
+
+    def add_query_parts(*parts: str) -> None:
+        tokens = [part.strip() for part in parts if part and part.strip()]
+        if not tokens:
+            return
+        add_query(" ".join(tokens))
+
+    enriched_terms = []
+    if user_name:
+        enriched_terms.append(f'"{user_name}"')
+    if user_company:
+        enriched_terms.append(f'"{user_company}"')
+    if user_title:
+        enriched_terms.append(f'"{user_title}"')
+    if user_location:
+        enriched_terms.append(f'"{user_location}"')
+    base_hint = " ".join(enriched_terms)
+
+    # Prioritise the direct email search variants before broader fallbacks.
+    add_query_parts(normalized_email, "linkedin.com/in", base_hint)
+    add_query_parts(normalized_email, "linkedin.com", base_hint)
+    add_query_parts(normalized_email, "linkedin", base_hint)
+    add_query_parts(normalized_email, base_hint)
+    add_query(f'"{normalized_email}" "linkedin.com/in" {base_hint}')
+    add_query(f'"{normalized_email}" "linkedin.com" {base_hint}')
+    add_query(f'"{normalized_email}" linkedin {base_hint}')
+
+    if email_local_part and email_local_part != normalized_email:
+        add_query_parts(email_local_part, "linkedin.com/in", base_hint)
+        add_query_parts(email_local_part, "linkedin.com", base_hint)
+        add_query_parts(email_local_part, "linkedin", base_hint)
+        add_query(f'"{email_local_part}" "linkedin.com/in" {base_hint}')
+        add_query(f'"{email_local_part}" "linkedin.com" {base_hint}')
+
+    if email_local_humanized and email_local_humanized not in {email_local_part, normalized_email}:
+        add_query_parts(email_local_humanized, "linkedin", base_hint)
+        add_query(f'"{email_local_humanized}" linkedin {base_hint}')
+
+    if normalized_email:
+        add_query(f'site:linkedin.com/in "{normalized_email}" {base_hint}')
+
+    if email_local_part:
+        add_query(f'site:linkedin.com/in "{email_local_part}" {base_hint}')
+
+    if email_local_humanized and email_local_humanized != email_local_part:
+        add_query(f'site:linkedin.com/in "{email_local_humanized}" {base_hint}')
+
+    if base_hint:
+        lookup_hint = user_name or email_local_humanized or email_local_part or normalized_email
+        add_query(
+            f'site:linkedin.com/in "{normalized_email}" {base_hint} '
+            f'intitle:"{lookup_hint}" -intitle:"profiles"'
+        )
+        if email_local_humanized:
+            add_query(
+                f'site:linkedin.com/in "{email_local_humanized}" {base_hint} '
+                f'intitle:"{lookup_hint}" -intitle:"profiles"'
+            )
+
+    candidate_records: List[Dict[str, str]] = []
+    seen_links: Set[str] = set()
+    best_llm_choice: Optional[LinkedinCandidateChoice] = None
+    best_llm_link: str = ""
+    HIGH_CONFIDENCE_THRESHOLD = 0.8
+    MIN_CONFIDENCE_THRESHOLD = 0.75
+
+    async def evaluate_with_llm() -> Optional[LinkedinCandidateChoice]:
+        nonlocal best_llm_choice, best_llm_link
+
+        llm_choice = await pick_best_linkedin_candidate_with_llm(
+            email=email,
+            user_name=user_name,
+            user_title=user_title,
+            user_location=user_location,
+            user_company=user_company,
+            candidates=candidate_records,
+            tool_config=tool_config,
+        )
+
+        if not llm_choice or not llm_choice.chosen_link:
+            return None
+
+        chosen_link = extract_user_linkedin_page(llm_choice.chosen_link)
+        if not chosen_link:
+            return None
+
+        llm_choice.chosen_link = chosen_link
+
+        if best_llm_choice is None or llm_choice.confidence > best_llm_choice.confidence:
+            best_llm_choice = llm_choice
+            best_llm_link = chosen_link
+            logger.debug(
+                "LLM updated best candidate: %s (confidence %.2f) reason: %s",
+                chosen_link,
+                llm_choice.confidence,
+                llm_choice.reasoning,
+            )
+
+        if llm_choice.confidence >= HIGH_CONFIDENCE_THRESHOLD:
+            logger.info(
+                "Returning LinkedIn user page by email via LLM scoring: %s (confidence %.2f)",
+                chosen_link,
+                llm_choice.confidence,
+            )
+            return llm_choice
+
+        return None
+
+    async with aiohttp.ClientSession() as session:
+        for query in queries:
+            query = query.strip()
+            if not query:
+                continue
+            logger.debug(f"Searching with query: {query}")
+
+            try:
+                results = await search_google_with_tools(query, 5, tool_config=tool_config)
+            except Exception:
+                logger.exception("Error searching for LinkedIn user URL by email.")
+                continue
+
+            if not isinstance(results, list) or len(results) == 0:
+                logger.debug("No results for this query, moving to next.")
+                continue
+
+            for result_item in results:
+                try:
+                    result_json = json.loads(result_item)
+                except (json.JSONDecodeError, IndexError):
+                    logger.debug("Failed to parse JSON from the search result.")
+                    continue
+
+                link = result_json.get('link', '')
+                if not link:
+                    continue
+
+                parsed_url = urlparse(link)
+                if 'linkedin.com/in' in (parsed_url.netloc + parsed_url.path):
+                    link = extract_user_linkedin_page(link)
+                    if not link or link in seen_links:
+                        continue
+
+                    title = result_json.get('title', '')
+                    snippet = result_json.get('snippet', '')
+                    subtitle = result_json.get('subtitle', '')
+
+                    candidate_records.append(
+                        {
+                            "link": link,
+                            "title": title,
+                            "snippet": snippet,
+                            "subtitle": subtitle,
+                            "query": query,
+                        }
+                    )
+                    if len(candidate_records) > 6:
+                        candidate_records.pop(0)
+                    seen_links.add(link)
+
+                    high_conf_choice = await evaluate_with_llm()
+                    if high_conf_choice:
+                        return {
+                            "linkedin_url": high_conf_choice.chosen_link,
+                            "confidence": high_conf_choice.confidence,
+                            "reasoning": high_conf_choice.reasoning,
+                        }
+
+    if best_llm_choice and best_llm_link and best_llm_choice.confidence >= MIN_CONFIDENCE_THRESHOLD:
+        logger.info(
+            "Returning LinkedIn user page by email via LLM scoring (best overall): %s (confidence %.2f)",
+            best_llm_link,
+            best_llm_choice.confidence,
+        )
+        return {
+            "linkedin_url": best_llm_link,
+            "confidence": best_llm_choice.confidence,
+            "reasoning": best_llm_choice.reasoning,
+        }
+
+    logger.info("No matching LinkedIn user page found using email queries.")
+    return None
+
+
 @assistant_tool
 async def find_user_linkedin_url_by_job_title_google(
     user_title: str,

{dhisana-0.0.1.dev213 → dhisana-0.0.1.dev214}/src/dhisana.egg-info/PKG-INFO

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