dhisana 0.0.1.dev100__tar.gz → 0.0.1.dev101__tar.gz

{dhisana-0.0.1.dev100 → dhisana-0.0.1.dev101}/PKG-INFO

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

{dhisana-0.0.1.dev100 → dhisana-0.0.1.dev101}/setup.py

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

{dhisana-0.0.1.dev100 → dhisana-0.0.1.dev101}/src/dhisana/utils/enrich_lead_information.py

@@ -18,7 +18,10 @@ from dhisana.utils.field_validators import (
     normalize_linkedin_url,
     normalize_linkedin_company_url,
     normalize_salesnav_url,
-    normalize_linkedin_company_salesnav_url
+    normalize_linkedin_company_salesnav_url,
+    validate_and_clean_email,
+    validation_organization_domain,
+    validate_website_url
 )
 from dhisana.utils.apollo_tools import enrich_user_info_with_apollo
 from dhisana.utils.assistant_tool_tag import assistant_tool
@@ -36,11 +39,6 @@ from dhisana.utils.serpapi_search_tools import (
     get_company_domain_from_google_search,
     get_company_website_from_linkedin_url,
 )
-from dhisana.utils.field_validators import (
-    validate_and_clean_email,
-    validation_organization_domain,
-    validate_website_url
-)
 
 import logging
 logging.basicConfig(level=logging.INFO)
@@ -48,23 +46,58 @@ logger = logging.getLogger(__name__)
 
 
 # ----------------------------------------------------------------------
-# The enrichment tools that are permissible for usage.
+# Allowed Enrichment Tools
 # ----------------------------------------------------------------------
 ALLOWED_ENRICHMENT_TOOLS = ["proxycurl", "apollo", "zoominfo"]
 
-# A map from tool name to the corresponding function that will enrich user info.
 USER_LOOKUP_TOOL_NAME_TO_FUNCTION_MAP = {
     "apollo": enrich_user_info_with_apollo,
     "proxycurl": enrich_user_info_with_proxy_curl,
 }
 
 
+# ----------------------------------------------------------------------
+# BasicLeadInformation model
+# ----------------------------------------------------------------------
+class BasicLeadInformation(BaseModel):
+    full_name: str = Field(..., description="Full name of the lead")
+    first_name: str = Field(..., description="First name of the lead")
+    last_name: str = Field(..., description="Last name of the lead")
+    email: str = Field(..., description="Email address of the lead")
+    primary_domain_of_organization: str = Field(..., description="Primary domain of the organization")
+    job_title: str = Field(..., description="Job Title of the lead")
+    phone: str = Field(..., description="Phone number of the lead")
+    headline: str = Field(..., description="Headline of the lead")
+    lead_location: str = Field(..., description="Location of the lead")
+    organization_name: str = Field(..., description="Current Company where lead works")
+    common_connections: int = Field(..., description="Number of common connections with the lead. Default 0")
+    followers_count: int = Field(..., description="Number of followers of the lead. Default 0")
+    tenure_in_current_role: str = Field(..., description="Tenure in the current role")
+    tenure_in_current_company: str = Field(..., description="Tenure in the current company")
+    connection_degree: str = Field(..., description="Degree of connection with the lead (1st, 2nd, 3rd)")
+    is_premium_account: bool = Field(..., description="Is the lead a premium account. Default is false.")
+    country_code: str = Field(..., description="Alpha-2 ISO3166 country code eg. US")
+
+
+# ----------------------------------------------------------------------
+# Helper: chunkify
+# ----------------------------------------------------------------------
+def chunkify(items: List[Any], chunk_size: int) -> List[List[Any]]:
+    """
+    Splits a list into sublists (chunks) of size `chunk_size`.
+    """
+    for i in range(0, len(items), chunk_size):
+        yield items[i : i + chunk_size]
+
+
+# ----------------------------------------------------------------------
+# Function: cleanup_user_name
+# ----------------------------------------------------------------------
 def cleanup_user_name(cloned_properties: dict) -> dict:
     """
     Cleans up user name fields: 'full_name', 'first_name', 'last_name'.
     Returns the updated dictionary. If values are invalid or placeholders, sets them to ''.
     """
-
     if not isinstance(cloned_properties, dict):
         return {}
 
@@ -86,8 +119,9 @@ def cleanup_user_name(cloned_properties: dict) -> dict:
         stripped = stripped.split("|", 1)[0]
         # Remove extra non-alphanumeric characters (but allow whitespace)
         stripped = re.sub(r"[^a-zA-Z0-9\s]", "", stripped)
-        # Capitalize first letter, lowercase the rest
-        return stripped.strip().capitalize()
+        
+        # Capitalize the first letter of each word, and lowercase the rest
+        return " ".join(word.capitalize() for word in stripped.strip().split())
 
     full_name = normalize(cloned_properties.get("full_name"))
     first_name = normalize(cloned_properties.get("first_name"))
@@ -100,41 +134,14 @@ def cleanup_user_name(cloned_properties: dict) -> dict:
     cloned_properties["full_name"] = full_name
     cloned_properties["first_name"] = first_name
     cloned_properties["last_name"] = last_name
+    
     return cloned_properties
 
 
-class BasicLeadInformation(BaseModel):
-    full_name: str = Field(..., description="Full name of the lead")
-    first_name: str = Field(..., description="First name of the lead")
-    last_name: str = Field(..., description="Last name of the lead")
-    email: str = Field(..., description="Email address of the lead")
-    primary_domain_of_organization: str = Field(..., description="Primary domain of the organization")
-    job_title: str = Field(..., description="Job Title of the lead")
-    phone: str = Field(..., description="Phone number of the lead")
-    headline: str = Field(..., description="Headline of the lead")
-    lead_location: str = Field(..., description="Location of the lead")
-    organization_name: str = Field(..., description="Current Company where lead works")
-    common_connections: int = Field(..., description="Number of common connections with the lead. Default 0")
-    followers_count: int = Field(..., description="Number of followers of the lead. Default 0")
-    tenure_in_current_role: str = Field(..., description="Tenure in the current role")
-    tenure_in_current_company: str = Field(..., description="Tenure in the current company")
-    connection_degree: str = Field(..., description="Degree of connection with the lead (1st, 2nd, 3rd)")
-    is_premium_account: bool = Field(..., description="Is the lead a premium account. Default is false.")
-    country_code: str = Field(..., description="Alpha-2 ISO3166 country code eg. US")
-
-
-def chunkify(items: List[Any], chunk_size: int) -> List[List[Any]]:
-    """
-    Splits a list into sublists (chunks) of size `chunk_size`.
-    """
-    for i in range(0, len(items), chunk_size):
-        yield items[i : i + chunk_size]
-
-
 # ----------------------------------------------------------------------
 # LLM-based cleanup for single lead
 # ----------------------------------------------------------------------
-async def get_clean_lead_info_with_llm(lead_info_str: str, tool_config) -> Dict[str, Any]:
+async def get_clean_lead_info_with_llm(lead_info_str: str, tool_config: Optional[dict]) -> Dict[str, Any]:
     """
     Takes a JSON string representation of partial lead info,
     returns a cleaned-up lead dictionary matching BasicLeadInformation fields.
@@ -163,21 +170,48 @@ async def get_clean_lead_info_with_llm(lead_info_str: str, tool_config) -> Dict[
     return lead_info.model_dump()
 
 
+# ----------------------------------------------------------------------
+# Helper: is_personal_email_domain
+# ----------------------------------------------------------------------
+def is_personal_email_domain(domain: str) -> bool:
+    """
+    Very simple check to see if the domain is one of the common free/personal
+    email providers. Could expand this list or integrate a third-party API
+    for more accuracy.
+    """
+    common_free_domains = {
+        "gmail.com", "yahoo.com", "hotmail.com", "outlook.com",
+        "protonmail.com", "icloud.com", "aol.com", "mail.com",
+        "pm.me", "yandex.com", "gmx.com"
+    }
+    domain = domain.strip().lower()
+    return (domain in common_free_domains) or domain.endswith(".edu")
+
+
 # ----------------------------------------------------------------------
 # Main validation & cleanup function
 # ----------------------------------------------------------------------
-async def validate_and_cleanup(cloned_properties: dict, tool_config: Optional[dict] = None) -> dict:
+async def validate_and_cleanup(
+    cloned_properties: dict,
+    tool_config: Optional[dict] = None,
+    use_strict_check: bool = False
+) -> dict:
     """
     Wrapper to validate & normalize various properties in a dictionary.
-    If `full_name`, `first_name`, or `last_name` is under 3 characters or contains
-    special characters, we fallback to `get_clean_lead_info_with_llm`.
-    Otherwise, we use the cheaper `cleanup_user_name`.
+
+    1) Clean up/validate typical fields.
+    2) If name fields appear invalid, fallback to LLM-based name inference.
+    3) If 'primary_domain_of_organization' AND 'organization_website' are both empty,
+       but there's a valid corporate email, use that as the domain.
+    4) (Optional) Enrich the organization info from the name if needed.
     """
 
     if not isinstance(cloned_properties, dict):
         return {}
 
-    # Normalize typical fields first
+    # ------------------------------------------------------------------
+    # Step 1: Normalize typical fields
+    # ------------------------------------------------------------------
     cloned_properties["user_linkedin_url"] = normalize_linkedin_url(
         cloned_properties.get("user_linkedin_url")
     )
@@ -203,19 +237,19 @@ async def validate_and_cleanup(cloned_properties: dict, tool_config: Optional[di
         cloned_properties.get("organization_name")
     )
 
-    # Now decide if we need LLM-based cleanup for the name fields
+    # ------------------------------------------------------------------
+    # Step 2: Basic name-check. If invalid => LLM fallback.
+    # ------------------------------------------------------------------
     def has_special_characters(val: str) -> bool:
         return bool(re.search(r"[^a-zA-Z0-9\s]", val))
 
     def is_invalid_name(val: str) -> bool:
-        """Invalid if < 3 chars OR contains any special characters."""
-        return len(val.strip()) < 3 or has_special_characters(val)
+        return (len(val.strip()) < 3) or has_special_characters(val)
 
     full_name = cloned_properties.get("full_name", "")
     first_name = cloned_properties.get("first_name", "")
     last_name = cloned_properties.get("last_name", "")
 
-    # If ANY are invalid => Use get_clean_lead_info_with_llm
     if (
         is_invalid_name(full_name)
         or is_invalid_name(first_name)
@@ -223,19 +257,44 @@ async def validate_and_cleanup(cloned_properties: dict, tool_config: Optional[di
     ):
         lead_info_str = str(cloned_properties)
         logger.info(
-            "Detected invalid name fields, using LLM to infer/correct name fields."
+            "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:
-            # Just replace relevant name fields if returned from LLM
             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:
-        # Use cheaper logic
+        # Use the cheaper logic
         cloned_properties = cleanup_user_name(cloned_properties)
 
+    # ------------------------------------------------------------------
+    # Step 3: If domain & website are empty but there's a corporate email
+    # ------------------------------------------------------------------
+    # - If email is present, check if domain is personal or corporate
+    # - If corporate, set primary_domain_of_organization from email domain
+    # ------------------------------------------------------------------
+    domain_empty = not cloned_properties.get("primary_domain_of_organization")
+    website_empty = not cloned_properties.get("organization_website")
+    email = cloned_properties.get("email", "")
+
+    if domain_empty and website_empty and email:
+        # parse domain from email
+        extracted_domain = email.split("@")[-1].strip().lower()
+        if extracted_domain and (not is_personal_email_domain(extracted_domain)):
+            # This is a "corporate" email domain, so use it
+            cloned_properties["primary_domain_of_organization"] = extracted_domain
+            cloned_properties["organization_website"] = f"https://www.{extracted_domain}"
+            logger.info("Set primary_domain_of_organization from corporate email domain.")
+    
+    if domain_empty and not website_empty:
+        from urllib.parse import urlparse
+        parsed_website = urlparse(cloned_properties["organization_website"])
+        possible_domain = parsed_website.netloc.replace("www.", "")
+        if possible_domain:
+            cloned_properties["primary_domain_of_organization"] = possible_domain
+            logger.info("Set primary_domain_of_organization from organization_website domain.")
     return cloned_properties
 
 @assistant_tool
@@ -266,7 +325,7 @@ async def enrich_lead_information(
 
     cloned_properties = await enrich_with_provider(cloned_properties, tool_config)
 
-    await set_organization_domain(
+    await enrich_organization_info_from_name(
         row=cloned_properties,
         use_strict_check=use_strict_check,
         tool_config=tool_config,
@@ -473,7 +532,6 @@ async def enrich_organization_info_from_name(
     """
     org_name_key = "organization_name"
     org_domain_key = "primary_domain_of_organization"
-    linkedin_url_key = "organization_linkedin_url"
     website_key = "organization_website"
 
     org_name = (row.get(org_name_key) or "").strip()
@@ -489,36 +547,7 @@ async def enrich_organization_info_from_name(
     # If domain or website is already present, we consider it enriched
     if row.get(org_domain_key) or row.get(website_key):
         return
-
-    # Try to fetch additional company info (domain, website, maybe LinkedIn)
-    company_info = await get_company_domain_from_llm_web_search(
-        company_name=org_name,
-        lead_info=row,
-        location="US",
-        tool_config=tool_config
-    )
-
-    if company_info and isinstance(company_info, dict):
-        # If the LLM found a domain, set it
-        if company_info.get("primary_domain_of_organization"):
-            row[org_domain_key] = company_info["primary_domain_of_organization"]
-
-        # If the LLM found an organization website, set it
-        if company_info.get("organization_website"):
-            row[website_key] = company_info["organization_website"]
-
-        # If there's a LinkedIn URL from LLM, set it
-        if company_info.get("organization_linkedin_url") and not row[linkedin_url_key]:
-            row[linkedin_url_key] = company_info["organization_linkedin_url"]
-            
-        if company_info.get("organization_name") and not row[org_name_key]:
-            row[org_name_key] = company_info["organization_name"]
-
-        # After setting them, run set_organization_domain to finalize or clean up domain
-        await set_organization_domain(row, use_strict_check, tool_config)
-    else:
-        # If LLM didn't return anything, at least set the domain to empty
-        row[org_domain_key] = ""
+    await set_organization_domain(row, use_strict_check, tool_config)
 
 
 async def set_organization_domain(
@@ -567,8 +596,21 @@ async def set_organization_domain(
                 location="US",
                 tool_config=tool_config
             )
-            extracted_domain = company_info.get("primary_domain_of_organization", "")
-            logger.debug("Found domain from Google search: %s", extracted_domain)
+            if company_info and isinstance(company_info, dict):
+                # If the LLM found a domain, set it
+                if company_info.get("primary_domain_of_organization") and not row[org_domain_key]:
+                    row[org_domain_key] = company_info["primary_domain_of_organization"]
+
+                # If the LLM found an organization website, set it
+                if company_info.get("organization_website") and not row[website_key]:
+                    row[website_key] = company_info["organization_website"]
+
+                # If there's a LinkedIn URL from LLM, set it
+                if company_info.get("organization_linkedin_url") and not row[linkedin_url_key]:
+                    row[linkedin_url_key] = company_info["organization_linkedin_url"]
+                    
+                if company_info.get("organization_name") and not row[org_name_key]:
+                    row[org_name_key] = company_info["organization_name"]
 
         row[org_domain_key] = extracted_domain or ""
         logger.debug("Final domain selected: %s", row[org_domain_key])
@@ -726,7 +768,9 @@ async def get_company_domain_from_llm_web_search(
         {lead_info}
         
         Search and gather any domain/website info or LinkedIn details.
-
+        DO NOT make up information about company. 
+        Find based on the domain in the leads email if its a corporate email, company name if sepcified to find the company name, website and domain.
+        
         **Output**:
         Return your final output as valid JSON with the following structure:
         {{

{dhisana-0.0.1.dev100 → dhisana-0.0.1.dev101}/src/dhisana/utils/research_lead.py

@@ -5,6 +5,7 @@ from dhisana.utils.clean_properties import cleanup_email_context
 from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
 
 def clean_nul_bytes(s: str) -> str:
+    s = s.replace('```markdown', '')
     return s.replace('\x00', '')
 
 class LeadResearchInformation(BaseModel):

{dhisana-0.0.1.dev100 → dhisana-0.0.1.dev101}/src/dhisana.egg-info/PKG-INFO

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