dhisana 0.0.1.dev243__py3-none-any.whl

dhisana/utils/proxycurl_search_leads.py

@@ -0,0 +1,426 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional
+
+import aiohttp
+from pydantic import BaseModel
+
+from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
+from dhisana.utils.proxy_curl_tools import (
+    get_proxycurl_access_token,
+    fill_in_missing_properties,
+    transform_company_data,
+)
+from dhisana.utils.cache_output_tools import cache_output
+from urllib.parse import urlparse, urlunparse
+from dhisana.utils.clean_properties import cleanup_properties
+from dhisana.utils.assistant_tool_tag import assistant_tool
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+# ────────────────────────────
+# 🛠  Small generic helpers
+# ────────────────────────────
+def _remove_empty_values(d: Dict[str, Any]) -> Dict[str, Any]:
+    """Return a copy of *d* without keys whose value is empty, None, or zero for integers."""
+    cleaned = {}
+    for k, v in d.items():
+        # Skip None values
+        if v is None:
+            continue
+        # Skip empty strings or whitespace-only strings
+        elif isinstance(v, str) and v.strip() == "":
+            continue
+        # Skip empty lists/arrays
+        elif isinstance(v, list) and len(v) == 0:
+            continue
+        # Skip zero values for integer fields (assuming they're not meaningful for search)
+        elif isinstance(v, int) and v == 0:
+            continue
+        # Keep all other values
+        else:
+            cleaned[k] = v
+    return cleaned
+
+
+def _build_common_params(
+    search_params: BaseModel,
+    max_entries: int,
+    enrich_profiles: bool,
+) -> Dict[str, Any]:
+    """Convert a Pydantic model into Proxycurl query params, removing empty/None values."""
+    params = search_params.model_dump(exclude_none=True)
+    params = _remove_empty_values(params)
+
+    params["page_size"] = max_entries if max_entries > 0 else 5
+    params["enrich_profiles"] = "enrich" if enrich_profiles else "skip"
+    params["use_cache"] = "if-present"
+    return params
+
+
+# ────────────────────────────
+# 📄  Search parameter schemas
+# ────────────────────────────
+class PeopleSearchParams(BaseModel):
+    current_role_title: Optional[str] = None
+    current_company_industry: Optional[str] = None
+    current_company_employee_count_min: Optional[int] = None
+    current_company_employee_count_max: Optional[int] = None
+    country: Optional[str] = None
+    region: Optional[str] = None
+    city: Optional[str] = None
+    summary: Optional[str] = None
+    current_job_description: Optional[str] = None
+    past_job_description: Optional[str] = None
+
+
+class CompanySearchParams(BaseModel):
+    country: Optional[str] = None
+    region: Optional[str] = None
+    city: Optional[str] = None
+    type: Optional[str] = None
+    follower_count_min: Optional[int] = None
+    follower_count_max: Optional[int] = None
+    name: Optional[str] = None
+    industry: Optional[str] = None
+    employee_count_max: Optional[int] = None
+    employee_count_min: Optional[int] = None
+    description: Optional[str] = None
+    founded_after_year: Optional[int] = None
+    founded_before_year: Optional[int] = None
+    funding_amount_max: Optional[int] = None
+    funding_amount_min: Optional[int] = None
+    funding_raised_after: Optional[str] = None
+    funding_raised_before: Optional[str] = None
+    public_identifier_in_list: Optional[str] = None
+    public_identifier_not_in_list: Optional[str] = None
+
+
+class JobSearchParams(BaseModel):
+    job_type: Optional[str] = None
+    experience_level: Optional[str] = None
+    when: Optional[str] = None
+    flexibility: Optional[str] = None
+    geo_id: Optional[int] = None
+    keyword: Optional[str] = None
+    search_id: Optional[str] = None
+
+
+# ────────────────────────────
+# 👤  People search
+# ────────────────────────────
+@assistant_tool
+async def proxycurl_people_search_leads(
+    search_params: PeopleSearchParams,
+    max_entries: int = 5,
+    enrich_profiles: bool = False,
+    tool_config: Optional[List[Dict[str, Any]]] = None,
+) -> List[Dict[str, Any]]:
+    """Search for leads on Proxycurl based on a plain‑English ICP description."""
+
+    params = _build_common_params(search_params, max_entries, enrich_profiles)
+
+    try:
+        api_key = get_proxycurl_access_token(tool_config)
+    except ValueError as e:
+        logger.error(str(e))
+        return []
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = "https://enrichlayer.com/api/v2/search/person"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    logger.error("Proxycurl search error %s", resp.status)
+                    return []
+                data = await resp.json()
+    except Exception as exc:
+        logger.exception("Exception during Proxycurl search: %s", exc)
+        return []
+
+    leads: List[Dict[str, Any]] = []
+    for item in (data.get("results") or [])[:max_entries]:
+        lead: Dict[str, Any] = {
+            "user_linkedin_url": item.get("linkedin_profile_url"),
+        }
+        profile = item.get("profile") or {}
+        if profile:
+            # Fill lead fields using profile data
+            lead = fill_in_missing_properties(lead, profile)
+            first_exp = (profile.get("experiences") or [{}])[0]
+            lead.setdefault("organization_name", first_exp.get("company", ""))
+            lead.setdefault(
+                "organization_linkedin_url",
+                first_exp.get("company_linkedin_profile_url", ""),
+            )
+
+            additional_props = lead.get("additional_properties") or {}
+            additional_props["pc_person_data"] = json.dumps(
+                cleanup_properties(profile)
+            )
+            lead["additional_properties"] = additional_props
+
+            linkedin_url = lead.get("user_linkedin_url")
+            if linkedin_url:
+                cache_output(
+                    "enrich_person_info_from_proxycurl", linkedin_url, profile
+                )
+
+        if cleaned := cleanup_properties(lead):
+            leads.append(cleaned)
+
+    return leads
+
+
+# ────────────────────────────
+# 🏢  Company search
+# ────────────────────────────
+@assistant_tool
+async def proxycurl_company_search_leads(
+    search_params: CompanySearchParams,
+    max_entries: int = 5,
+    enrich_profiles: bool = False,
+    tool_config: Optional[List[Dict[str, Any]]] = None,
+) -> List[Dict[str, Any]]:
+    """Search for companies on Proxycurl based on given parameters."""
+
+    params = _build_common_params(search_params, max_entries, enrich_profiles)
+
+    try:
+        api_key = get_proxycurl_access_token(tool_config)
+    except ValueError as e:
+        logger.error(str(e))
+        return []
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = "https://enrichlayer.com/api/v2/search/company"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    logger.error("Proxycurl company search error %s", resp.status)
+                    return []
+                data = await resp.json()
+    except Exception as exc:
+        logger.exception("Exception during Proxycurl company search: %s", exc)
+        return []
+
+    companies: List[Dict[str, Any]] = []
+    for item in (data.get("results") or [])[:max_entries]:
+        company: Dict[str, Any] = {
+            "organization_linkedin_url": item.get("linkedin_profile_url"),
+        }
+        profile = item.get("profile") or {}
+        if profile:
+            # Copy mapped properties from the enriched profile
+            transformed = transform_company_data(profile)
+            company.update(transformed)
+
+            # Store the raw profile JSON for reference
+            additional_props = company.get("additional_properties") or {}
+            additional_props["pc_company_data"] = json.dumps(
+                cleanup_properties(profile)
+            )
+            company["additional_properties"] = additional_props
+
+            linkedin_url = company.get("organization_linkedin_url") or ""
+            if linkedin_url and "linkedin.com/company" in linkedin_url:
+                parsed_url = urlparse(linkedin_url)
+                if parsed_url.netloc != "www.linkedin.com":
+                    standardized_netloc = "www.linkedin.com"
+                    standardized_path = parsed_url.path
+                    if not standardized_path.startswith("/company/"):
+                        standardized_path = "/company" + standardized_path
+                    standardized_url = urlunparse(
+                        parsed_url._replace(
+                            netloc=standardized_netloc,
+                            path=standardized_path,
+                        )
+                    )
+                else:
+                    standardized_url = linkedin_url
+                if standardized_url and not standardized_url.endswith("/"):
+                    standardized_url += "/"
+                cache_output(
+                    "enrich_organization_info_from_proxycurl",
+                    standardized_url,
+                    transformed,
+                )
+
+        if cleaned := cleanup_properties(company):
+            companies.append(cleaned)
+
+    return companies
+
+
+# ────────────────────────────
+# 💼  Job search
+# ────────────────────────────
+@assistant_tool
+async def proxycurl_job_search(
+    search_params: JobSearchParams,
+    max_entries: int = 5,
+    enrich_profiles: bool = False,
+    tool_config: Optional[List[Dict[str, Any]]] = None,
+) -> List[Dict[str, Any]]:
+    """List jobs posted by a company using Proxycurl's job search API."""
+
+    # Job search endpoint does not support enrich_profiles
+    params = _build_common_params(search_params, max_entries, enrich_profiles=enrich_profiles)
+
+    try:
+        api_key = get_proxycurl_access_token(tool_config)
+    except ValueError as e:
+        logger.error(str(e))
+        return []
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = "https://enrichlayer.com/api/v2/company/job"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    logger.error("Proxycurl job search error %s", resp.status)
+                    return []
+                data = await resp.json()
+    except Exception as exc:
+        logger.exception("Exception during Proxycurl job search: %s", exc)
+        return []
+
+    job_entries: List[Dict[str, Any]] = []
+    for item in (data.get("job") or data.get("jobs") or [])[:max_entries]:
+        job: Dict[str, Any] = {
+            "organization_name": item.get("company"),
+            "organization_linkedin_url": item.get("company_url"),
+            "job_title": item.get("job_title"),
+            "job_posting_url": item.get("job_url"),
+            "list_date": item.get("list_date"),
+            "location": item.get("location"),
+        }
+        additional_props = job.get("additional_properties") or {}
+        additional_props["pc_job_data"] = json.dumps(item)
+        job["additional_properties"] = additional_props
+
+        job_url = job.get("job_posting_url")
+        if job_url:
+            cache_output("enrich_job_info_from_proxycurl", job_url, item)
+        if cleaned := cleanup_properties(job):
+            job_entries.append(cleaned)
+
+    return job_entries
+
+
+# ────────────────────────────
+# 📊  Job count
+# ────────────────────────────
+@assistant_tool
+async def proxycurl_job_count(
+    search_params: JobSearchParams,
+    tool_config: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """Get the count of jobs posted by a company using Proxycurl's job count API."""
+
+    # Job count endpoint does not support enrich_profiles or max_entries
+    params = search_params.model_dump(exclude_none=True)
+    params = _remove_empty_values(params)
+    
+    # Job count endpoint doesn't need page_size or enrich_profiles
+    if "page_size" in params:
+        del params["page_size"]
+
+    try:
+        api_key = get_proxycurl_access_token(tool_config)
+    except ValueError as e:
+        logger.error(str(e))
+        return {"count": 0}
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = "https://enrichlayer.com/api/v2/company/job/count"
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    logger.error("Proxycurl job count error %s", resp.status)
+                    return {"count": 0}
+                data = await resp.json()
+    except Exception as exc:
+        logger.exception("Exception during Proxycurl job count: %s", exc)
+        return {"count": 0}
+
+    return {"count": data.get("count", 0)}
+
+
+# ────────────────────────────
+# 🔍  Company Profile - Get Search ID
+# ────────────────────────────
+@assistant_tool
+async def proxycurl_get_company_search_id(
+    company_url: str,
+    tool_config: Optional[List[Dict[str, Any]]] = None,
+) -> Dict[str, Any]:
+    """Get a company's search ID using Proxycurl's Company Profile endpoint.
+    
+    The search_id is required for other Proxycurl endpoints like job search and job count.
+    
+    Args:
+        company_url: LinkedIn company profile URL (e.g., "https://www.linkedin.com/company/microsoft/")
+        tool_config: Optional tool configuration containing API key
+        
+    Returns:
+        Dictionary containing search_id and basic company info, or error info if failed
+    """
+
+    try:
+        api_key = get_proxycurl_access_token(tool_config)
+    except ValueError as e:
+        logger.error(str(e))
+        return {"error": str(e), "search_id": None}
+
+    headers = {"Authorization": f"Bearer {api_key}"}
+    url = "https://enrichlayer.com/api/v2/company"
+    
+    params = {
+        "url": company_url,
+        "use_cache": "if-present",
+        "fallback_to_cache": "on-error"
+    }
+
+    try:
+        async with aiohttp.ClientSession() as session:
+            async with session.get(url, headers=headers, params=params) as resp:
+                if resp.status != 200:
+                    logger.error("Proxycurl company profile error %s", resp.status)
+                    return {"error": f"HTTP {resp.status}", "search_id": None}
+                data = await resp.json()
+    except Exception as exc:
+        logger.exception("Exception during Proxycurl company profile lookup: %s", exc)
+        return {"error": str(exc), "search_id": None}
+
+    # Extract the key information
+    search_id = data.get("search_id")
+    name = data.get("name")
+    linkedin_internal_id = data.get("linkedin_internal_id")
+    industry = data.get("industry")
+    
+    result = {
+        "search_id": search_id,
+        "name": name,
+        "linkedin_internal_id": linkedin_internal_id,
+        "industry": industry,
+        "company_url": company_url
+    }
+    
+    if search_id:
+        logger.info(f"Successfully retrieved search_id '{search_id}' for company '{name}'")
+    else:
+        logger.warning(f"No search_id found for company at {company_url}")
+        result["error"] = "No search_id found in response"
+    
+    return result

dhisana/utils/python_function_to_tools.py

@@ -0,0 +1,83 @@
+# Convert python function to OPENAI function spec and add it to allowed list.
+# This allows passing any python function to the assistant API for orchestration.
+
+import inspect
+from typing import List, Union, get_type_hints, get_args, get_origin
+
+
+def get_function_spec_from_python_function(func):
+    # Get function name
+    func_name = func.__name__
+    # Get docstring for the description
+    description = inspect.getdoc(func) or ""
+    # Get function signature
+    signature = inspect.signature(func)
+    # Get type hints
+    type_hints = get_type_hints(func)
+
+    # Build parameters
+    parameters = {
+        "type": "object",
+        "properties": {},
+        "required": [],
+        "additionalProperties": False
+    }
+
+    for param_name, param in signature.parameters.items():
+        param_schema = {}
+        param_type = type_hints.get(param_name, str)
+
+        # Determine the JSON schema type based on the annotation
+        origin = get_origin(param_type)
+        args = get_args(param_type)
+
+        if origin is Union and type(None) in args:
+            # Optional type
+            actual_type = args[0]
+        else:
+            actual_type = param_type
+
+        if actual_type == str:
+            param_schema["type"] = "string"
+        elif actual_type == int:
+            param_schema["type"] = "integer"
+        elif actual_type == float:
+            param_schema["type"] = "number"
+        elif actual_type == bool:
+            param_schema["type"] = "boolean"
+        elif origin in [list, List]:
+            param_schema["type"] = "array"
+            param_schema["items"] = {"type": "string"}
+        else:
+            param_schema["type"] = "string"  # Default to string
+
+        # Parameter description can be empty or populated from elsewhere
+        param_schema["description"] = ""
+
+        parameters["properties"][param_name] = param_schema
+
+        # if param.default == inspect.Parameter.empty:
+        parameters["required"].append(param_name)
+
+    # Truncate description if it exceeds 1024 characters. OpenAI API has a limit of 1024 characters for description.
+    if len(description) > 1024:
+        description = description[:1021] + '...'
+    
+    function_spec = {
+        "type": "function",
+        "function": {
+            "name": func_name,
+            "strict": True,
+            "description": description,
+            "parameters": parameters
+        }
+    }
+
+    return function_spec
+
+async def convert_functions_to_openai_spec(functions):
+    function_specs = []
+    for func_name, func in functions.items():
+        spec = get_function_spec_from_python_function(func)
+        function_specs.append(spec)
+    return function_specs

dhisana/utils/research_lead.py

@@ -0,0 +1,176 @@
+from typing import Dict, List, Optional
+from pydantic import BaseModel
+from dhisana.utils.assistant_tool_tag import assistant_tool
+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', '')
+
+def _remove_excluded_fields(data: Dict) -> Dict:
+    """
+    Return a copy of `data` that excludes keys named 'id'
+    or that end in '_by', '_id', '_to', or '_at'.
+    """
+    excluded_keys = {"id"}
+    excluded_endings = ["_by", "_id", "_to", "_at", "_status", "research_summary"]
+
+    cleaned = {}
+    for k, v in data.items():
+        if k in excluded_keys:
+            continue
+        if any(k.endswith(suffix) for suffix in excluded_endings):
+            continue
+        cleaned[k] = v
+    return cleaned
+
+class LeadResearchInformation(BaseModel):
+    research_summary: str
+
+@assistant_tool
+async def research_lead_with_full_info_ai(
+    user_properties: dict, 
+    instructions: str, 
+    tool_config: Optional[List[Dict]] = None
+):
+    """
+    Research on lead provided given input. Provide Detailed Summary.
+    """
+    # Clean user properties (e.g. remove newlines, sanitize strings, etc.)
+    user_properties = cleanup_email_context(user_properties)
+
+    # Remove excluded fields from user_properties
+    user_properties = _remove_excluded_fields(user_properties)
+
+    # Optionally remove any known keys that should not appear (e.g. 'date_extracted')
+    user_properties.pop("date_extracted", None)
+
+    instructions = f"""
+        Please read the following user information and instructions, then produce a detailed summary of the lead in the specified format.
+        ---
+        Lead Data:
+        {user_properties}
+
+        Instructions:
+        {instructions}
+        ---
+
+        **Task**:
+        Give a detailed summary of the lead based on the provided data. The summary should include the following sections (only if relevant data is present):
+
+        1. About Lead 
+        2. Experience
+        3. Education
+        4. Skills
+        5. Recommendations
+        6. Accomplishments
+        7. Interests
+        8. Connections
+        9. Current Company Information
+        10. Contact Information
+        11. Addtional Info:
+            a. Include any githbub information like handle, repositories owned etc if present.
+            b. Include any twitter information like handle, followers etc if present.
+            c. Includ any youtube channel information like handle, subscribers etc if present.
+            d. Include any other social media information like handle, followers etc if present.
+        
+
+        - In the **About** section, create a clear, concise description of the lead that can be used for sales prospecting.
+        - In the **Current Company Information** section, summarize what the lead’s current company does. 
+        - In **Current Company Information** include employee headcount, revenue, industry, HQ Location of the current company.
+        - Have the above section headers even if section content is empty.
+        - DO NOT include any ids, userIds or GUIDS in the output.
+
+        **Output**:
+        Return your final output as valid JSON with the following structure:
+        {{
+            "research_summary": "Detailed summary about lead. The summary should be neatly formatted in GitHub-Flavored Markdown, and include all the key information from the listed sections."
+        }}
+    """
+    response, status = await get_structured_output_internal(
+        instructions, 
+        LeadResearchInformation, 
+        model="gpt-5.1-chat", 
+        tool_config=tool_config
+    )
+    if status == "SUCCESS":
+        response.research_summary = clean_nul_bytes(response.research_summary)
+        return response.model_dump()
+    else:
+        return {"research_summary": ""}
+
+# --------------------------------------------
+# COMPANY-RELATED MODELS & FUNCTION (FIXED)
+# --------------------------------------------
+class CompanyResearchInformation(BaseModel):
+    research_summary: str
+
+@assistant_tool
+async def research_company_with_full_info_ai(
+    company_properties: dict, 
+    instructions: str, 
+    tool_config: Optional[List[Dict]] = None
+):
+    """
+    Research on company provided given input. Provide a Detailed Summary.
+    
+    Parameters:
+    company_properties (dict): Information about the company.
+    instructions (str): Additional instructions for generating the detailed summary.
+    tool_config (Optional[List[Dict]]): Configuration for the tool (default is None).
+    
+    Returns:
+    dict: The JSON response containing the detailed research summary of the company.
+    """
+    # Clean company properties (e.g. remove newlines, sanitize strings, etc.)
+    company_properties = cleanup_email_context(company_properties)
+
+    # Remove excluded fields from company_properties
+    company_properties = _remove_excluded_fields(company_properties)
+
+    instructions = f"""
+        Please read the following company information and instructions, then produce a detailed summary of the company in the specified format.
+        ---
+        Company Data include name, domain and website:
+        {company_properties}
+
+        Instructions:
+        {instructions}
+        ---
+
+        **Task**:
+        Give a short summary of the company based on the provided data. Include **firmographic details** if they are present. 
+        The summary should have the following sections (only include them if there is relevant data):
+
+        1. About Company
+        2. Industry
+        3. Location / HQ
+        4. Employee Headcount
+        5. Revenue
+        6. Funding Information
+        7. Additional Firmographics (e.g. markets, expansions, or any other relevant data)
+        
+        - In the **About Company** section, create a clear, concise description of what the company does (suitable for sales prospecting).
+        - Do not include any IDs, userIds, or GUIDs in the output.
+        - Have the above section headers even if section content is empty.
+        Use web search to find additional information about the company using company name and domain. Search what it does, news, and funding.
+
+        **Output**:
+        Return your final output as valid JSON with the following structure:
+        {{
+            "research_summary": "Detailed summary about the company. The summary should be neatly formatted in GitHub-Flavored Markdown, and include all the key information from the listed sections."
+        }}
+    """
+    response, status = await get_structured_output_internal(
+        instructions,
+        CompanyResearchInformation,
+        model="gpt-5.1-chat",
+        use_web_search=False,
+        tool_config=tool_config
+    )
+    if status == "SUCCESS":
+        response.research_summary = clean_nul_bytes(response.research_summary)
+        return response.model_dump()
+    else:
+        return {"research_summary": ""}