dhisana 0.0.1.dev243__py3-none-any.whl

dhisana/utils/generate_leads_salesnav.py

@@ -0,0 +1,303 @@
+import json
+import logging
+from typing import Any, Dict, List, Optional, Tuple
+
+from dhisana.schemas.sales import SmartList
+from dhisana.utils.generate_structured_output_internal import get_structured_output_internal
+from dhisana.utils.workflow_code_model import WorkflowPythonCode
+
+# Initialize logger
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+async def generate_leads_code(
+    filters: str,
+    example_url: str,
+    max_pages: int = 1,
+    tool_config: Optional[List[Dict[str, Any]]] = None
+) -> Tuple[Dict[str, Any], str]:
+    """
+    Generate a workflow code (Python code) from an English description, specifically
+    to create a list from Sales Navigator.
+
+    Returns:
+      A tuple of:
+       - A dict containing {'workflow_python_code': '...'} 
+       - A string representing status, e.g., 'SUCCESS' or 'ERROR'.
+    """
+    system_message = (
+        "You are a helpful AI assistant who is an expert python coder. I want you to convert "
+        "an English description of a requirement provided by user into an executable Python "
+        "function called create_list_from_sales_navigator. Your output must be valid Python code. "
+        "The provided example shows how the structure looks like and what methods you can use. "
+        "Make sure the imports are present within the function definition itself. Make sure the "
+        "logging library is imported and logger defined within the function. "
+        "Use the output function signature:\n"
+        "    async def create_list_from_sales_navigator(filters, example_url, max_pages, tool_config)\n"
+    )
+
+    example_of_workflow_code = (
+        '''
+        async def create_list_from_sales_navigator(filters, example_url, max_pages, tool_config):
+            """
+            Example workflow demonstrating how to create a list from Sales Navigator.
+            Returns ("SUCCESS", unique_leads) or ("ERROR", []).
+            """
+            # Make sure required imports are there within the function definition itself.
+            import asyncio
+            import logging
+            from typing import Any, Dict, List, Optional, Tuple
+            from dhisana.utils.agent_task import execute_task
+            from dhisana.utils.compose_salesnav_query import generate_salesnav_people_search_url
+
+            # Make sure the logger is present.
+            logger = logging.getLogger(__name__)
+            logging.basicConfig(level=logging.INFO)
+
+            try:
+                logger.info("Starting custom_workflow execution")
+
+                if not example_url:
+                    # Generate a Sales Navigator URL
+                    result = await generate_salesnav_people_search_url(
+                        english_description=filters,
+                        tool_config=tool_config
+                    )
+                    if not result:
+                        logger.error("generate_salesnav_people_search_url returned no result")
+                        return "ERROR", []
+
+                    salesnav_url = result.get('linkedin_salenav_url_with_query_parameters', None)
+                    logger.info("Sales Navigator URL obtained: %s", salesnav_url)
+
+                    if not salesnav_url:
+                        logger.warning("No valid URL returned; cannot proceed.")
+                        return "ERROR", []
+                else:
+                    salesnav_url = example_url
+
+                # Extract leads from the URL
+                command_args = {
+                    "salesnav_url_list_leads": salesnav_url,
+                    "max_pages": max_pages,
+                    "enrich_detailed_lead_information": False,
+                    "enrich_detailed_company_information": False,
+                }
+                try:
+                    extraction_result = await execute_task(
+                        "extract_leads_information",
+                        command_args,
+                        tool_config=tool_config
+                    )
+                except Exception as exc:
+                    logger.exception("Error while extracting leads: %s", exc)
+                    return "ERROR", []
+
+                leads = extraction_result.get('data', [])
+                logger.info("Number of leads extracted: %d", len(leads))
+
+                if not leads:
+                    return "SUCCESS", []
+
+                # Deduplicate leads
+                unique_leads = {}
+                for lead in leads:
+                    lead_url = lead.get("user_linkedin_salesnav_url")
+                    if lead_url:
+                        unique_leads[lead_url] = lead
+
+                deduped_leads = list(unique_leads.values())
+                logger.info("Unique leads after deduplication: %d", len(deduped_leads))
+
+                logger.info("Completed custom_workflow with success.")
+                return "SUCCESS", deduped_leads
+
+            except Exception as e:
+                logger.exception("Exception in custom_workflow: %s", e)
+                return "ERROR", []
+        '''
+    )
+
+    # Short note if user has or hasn't provided a Sales Navigator URL
+    user_provided_url = "Keep user_input_salesnav_url variable as empty."
+    if "linkedin.com/sales/search/" in filters:
+        user_provided_url = "Use user_input_salesnav_url as provided by user"
+
+    # Explanation of possible filters
+    supported_filters_explanation = """
+        Sales Navigator filters include (not exhaustive):
+            - PAST_COLLEAGUE
+            - CURRENT_TITLE
+            - PAST_TITLE
+            - CURRENT_COMPANY
+            - PAST_COMPANY
+            - GEOGRAPHY (REGION)
+            - INDUSTRY
+            - SCHOOL
+            - CONNECTION (RELATIONSHIP)
+            - CONNECTIONS_OF
+            - GROUP
+            - COMPANY_HEADCOUNT
+            - COMPANY_TYPE
+            - SENIORITY_LEVEL
+            - YEARS_IN_POSITION
+            - YEARS_IN_COMPANY
+            - FOLLOWING_YOUR_COMPANY (FOLLOWS_YOUR_COMPANY)
+            - VIEWED_YOUR_PROFILE
+            - CHANGED_JOBS (RECENTLY_CHANGED_JOBS)
+            - POSTED_ON_LINKEDIN
+            - MENTIONED_IN_NEWS
+            - TECHNOLOGIES_USED
+            - ANNUAL_REVENUE
+            - LEAD_INTERACTIONS (Viewed Profile, Messaged)
+            - SAVED_LEADS_AND_ACCOUNTS
+            - WITH_SHARED_EXPERIENCES
+            - FIRST_NAME
+            - LAST_NAME
+            - FUNCTION
+            - YEARS_OF_EXPERIENCE
+            - YEARS_AT_CURRENT_COMPANY
+            - YEARS_IN_CURRENT_POSITION
+            - COMPANY_HEADQUARTERS
+    """
+
+    # Build the user prompt
+    user_prompt = f"""
+    {system_message}
+    Do the following step by step:
+    1. Think about the leads the user wants to query and filters to use for the same. 
+    2. If the user has provided a sales navigator url use that.
+    3. Take a look at the examples provided to construct the URL if user has not provided one. 
+    4. Think about the code example provided and see how you will fill the english_request_for_salesnav_search and user_input_salesnav_url correctly.
+    5. Generate the correct python code which takes care of above requirements. 
+    6. Make sure the code is valid and returns results in the format ("SUCCESS", leads_list) or ("ERROR", []).
+    7. Return the result in valid JSON format filled in workflow_python_code.
+
+    The user wants to generate code in python that performs the following:
+
+    "{filters}"
+
+    {user_provided_url}
+
+    Example of a workflow python code:
+    {example_of_workflow_code}
+
+    If user has provided a Sales Navigator URL set it to user_input_salesnav_url in the code 
+    and pass as input to generate_salesnav_people_search_url.
+
+    Each lead returned has at least:
+    full_name, first_name, last_name, email, user_linkedin_salesnav_url, organization_linkedin_salesnav_url,
+    user_linkedin_url, primary_domain_of_organization, job_title, phone, headline,
+    lead_location, organization_name, organization_website, summary_about_lead, keywords,
+    number_of_linkedin_connections
+
+    Following are some common methods available:
+    1. generate_salesnav_people_search_url - to generate Sales Navigator URL from plain English query.
+       (Supported filters: {supported_filters_explanation})
+
+    The output function signature MUST be:
+      async def create_list_from_sales_navigator(filters, example_url, max_pages, tool_config):
+
+    Double check to make sure the generated python code is valid and returns results in the format 
+    ("SUCCESS", leads_list) or ("ERROR", []).
+    Output HAS to be valid JSON like:
+    {{
+        "workflow_python_code": "code that has been generated"
+    }}
+    """
+
+    # Invoke LLM to generate code
+    response, status = await get_structured_output_internal(
+        user_prompt,
+        WorkflowPythonCode,
+        tool_config=tool_config
+    )
+
+    # Return dict + status
+    return response.model_dump(), status
+
+
+async def generate_leads_salesnav(
+    filter_object: Dict[str, Any],
+    request: SmartList,
+    example_url: str,
+    tool_config: Optional[List[Dict[str, Any]]] = None
+) -> str:
+    """
+    1) Generates Python workflow code from user's filter_object + example_url.
+    2) Executes the code to query Sales Navigator.
+    3) Returns JSON with {"status": <STATUS>, "leads": [list_of_leads]} or an error message.
+    """
+
+    # Calculate max_pages from request
+    # Each page is assumed to have ~20 leads
+    pages = int(request.max_items_to_search / 20) if request.max_items_to_search else 1
+    if pages < 1:
+        pages = 1
+    if pages > 90:
+        pages = 90
+
+    # Generate the code
+    response, status = await generate_leads_code(
+        filters=str(filter_object),
+        example_url=example_url,
+        max_pages=pages,
+        tool_config=tool_config
+    )
+
+    # If successful, try to run the code
+    if status == "SUCCESS" and response and response.get("workflow_python_code"):
+        code = response["workflow_python_code"]
+        if not code:
+            return json.dumps({"error": "No workflow code generated.", "status": status})
+
+        logger.info("Generated workflow code:\n%s", code)
+
+        local_vars: Dict[str, Any] = {}
+        global_vars: Dict[str, Any] = {}
+
+        try:
+            # Execute the generated code
+            exec(code, global_vars, local_vars)
+            create_fn = local_vars.get("create_list_from_sales_navigator")
+            if not create_fn:
+                raise RuntimeError("No 'create_list_from_sales_navigator' function found in generated code.")
+
+            async def run_create_list(flt: str, ex_url: str, mx_pages: int, t_cfg: Optional[List[Dict[str, Any]]]):
+                return await create_fn(flt, ex_url, mx_pages, t_cfg)
+
+            # Invoke the function
+            try:
+                result = await run_create_list(str(filter_object), example_url, pages, tool_config)
+            except Exception as e:
+                logger.exception("Error while running create_list_from_sales_navigator.")
+                return json.dumps({"status": "ERROR", "error": str(e)})
+
+            # Expect a tuple like ("SUCCESS", leads_list) or ("ERROR", [])
+            if not isinstance(result, tuple) or len(result) != 2:
+                return json.dumps({
+                    "status": "ERROR",
+                    "error": "Workflow code did not return an expected (status, leads_list) tuple."
+                })
+
+            status_returned, leads_list = result
+            if status_returned != "SUCCESS":
+                return json.dumps({
+                    "status": status_returned,
+                    "error": "Workflow returned an error status.",
+                    "leads": leads_list
+                })
+
+            # Return success + leads
+            return json.dumps({
+                "status": status_returned,
+                "leads": leads_list
+            })
+
+        except Exception as e:
+            logger.exception("Exception occurred while executing workflow code.")
+            return json.dumps({"status": "ERROR", "error": str(e)})
+
+    # If code generation failed or no code
+    return json.dumps({"error": "No workflow code generated.", "status": status})

dhisana/utils/generate_linkedin_connect_message.py

@@ -0,0 +1,224 @@
+# ----------------------------------------------------------------------
+# LinkedIn Message Generation Code (Refactored to mirror email structure)
+# ----------------------------------------------------------------------
+
+from typing import Dict, List, Optional
+from pydantic import BaseModel
+from datetime import datetime
+
+from dhisana.schemas.sales import (
+    ContentGenerationContext, 
+    ConversationContext,
+    CampaignContext,
+    Lead, 
+    MessageGenerationInstructions, 
+    MessageItem, 
+    SenderInfo
+)
+from dhisana.utils.generate_structured_output_internal import (
+    get_structured_output_internal,
+    get_structured_output_with_assistant_and_vector_store
+)
+from dhisana.utils.assistant_tool_tag import assistant_tool
+
+# ----------------------------------------------------------------------
+# LinkedIn Connection Message Schema
+# ----------------------------------------------------------------------
+class LinkedInConnectMessage(BaseModel):
+    body: str
+
+# ----------------------------------------------------------------------
+# Cleanup function (similar to cleanup_email_context)
+# ----------------------------------------------------------------------
+def cleanup_linkedin_context(linkedin_context: ContentGenerationContext) -> ContentGenerationContext:
+    """
+    Return a copy of ContentGenerationContext without unneeded or sensitive fields 
+    for LinkedIn generation.
+    """
+    clone_context = linkedin_context.copy(deep=True)
+    
+    # Example: remove irrelevant external data for this context
+    if clone_context.external_known_data:
+        clone_context.external_known_data.external_openai_vector_store_id = None
+
+    # Remove extra fields on the lead_info if desired
+    clone_context.lead_info.task_ids = None
+    clone_context.lead_info.email_validation_status = None
+    clone_context.lead_info.linkedin_validation_status = None
+    clone_context.lead_info.research_status = None
+    clone_context.lead_info.enchrichment_status = None
+
+    return clone_context
+
+# ----------------------------------------------------------------------
+# Known Framework Variations (fallback if user instructions are not provided)
+# ----------------------------------------------------------------------
+LINKEDIN_FRAMEWORK_VARIATIONS = [
+    "Use a friendly intro mentioning their role and a quick reason to connect.",
+    "Use social proof: reference an industry success story or insight.",
+    "Use a brief mention of mutual interest or connection.",
+    "Use P-S-B style (Pain, Solution, Benefit) but under 40 words.",
+    "Use a 3-Bullet Approach: Industry/Pain, Value, Simple Ask."
+]
+
+# ----------------------------------------------------------------------
+# Core function to generate a LinkedIn copy (similar to generate_personalized_email_copy)
+# ----------------------------------------------------------------------
+async def generate_personalized_linkedin_copy(
+    linkedin_context: ContentGenerationContext,
+    variation_text: str,
+    tool_config: Optional[List[Dict]] = None,
+) -> dict:
+    """
+    Generate a personalized LinkedIn connection message using the provided context and instructions.
+
+    Steps:
+      1. Build a prompt referencing 6 main sections:
+          (a) Lead Info
+          (b) Sender Info
+          (c) Campaign Info
+          (d) Variation / Instructions
+          (e) External Data (if any)
+          (f) Current Conversation
+      2. Generate the LinkedIn message with or without vector store usage.
+      3. Return the final subject & body, ensuring < 40 words.
+    """
+    cleaned_context = cleanup_linkedin_context(linkedin_context)
+
+    lead_data = cleaned_context.lead_info or Lead()
+    sender_data = cleaned_context.sender_info or SenderInfo()
+    campaign_data = cleaned_context.campaign_context or CampaignContext()
+    conversation_data = cleaned_context.current_conversation_context or ConversationContext()
+
+    # Construct the consolidated prompt
+    prompt = f"""
+        Hi AI Assistant,
+
+        Below is the context in 6 main sections. Use it to craft a concise, professional LinkedIn connection request message:
+        Linked in connect message HAS to be maximum of 40 words. DO NOT go more than 40 words.
+
+        1) Lead Information:
+        {lead_data.dict()}
+
+        2) Sender Information:
+        Full Name: {sender_data.sender_full_name or ''}
+        First Name: {sender_data.sender_first_name or ''}
+        Last Name: {sender_data.sender_last_name or ''}
+        Bio: {sender_data.sender_bio or ''}
+
+        3) Campaign Information:
+        Product Name: {campaign_data.product_name or ''}
+        Value Proposition: {campaign_data.value_prop or ''}
+        Call To Action: {campaign_data.call_to_action or ''}
+        Pain Points: {campaign_data.pain_points or []}
+        Proof Points: {campaign_data.proof_points or []}
+
+        4) Follow these Instructions to generate the likedin connection request message:
+        {variation_text}
+
+        5) External Data / Vector Store:
+        (File search or additional context if available.)
+
+        6) Current Conversation Context:
+        Email Thread: {conversation_data.current_email_thread or ''}
+        LinkedIn Thread: {conversation_data.current_linkedin_thread or ''}
+
+        IMPORTANT REQUIREMENTS:
+        - Output must be JSON "body" of the message.
+        - The entire message body must be under 40 words total.
+        - In the body DO NOT include any HTML tags like <a>, <b>, <i>, etc.
+        - The body should be in plain text.
+        - If there is a link provided in body use it as is. dont wrap it in any HTML tags.
+        - No placeholders or extra instructions in the final output.
+        - Do not include personal addresses, IDs, or irrelevant internal data.
+        - Linked in message always has saluatation Hi <First Name>, unless specified otherwise.
+        - <First Name> is the first name of the lead. Its conversational name. It does not have any special characters or spaces.
+        - Make sure the signature in body has the sender_first_name is correct and in the format user has specified.
+        - User conversational name for company name if used.
+        - Make sure the body text is well-formatted and that newline and carriage-return characters are correctly present and preserved in the message body.
+        - Do Not use em dash in the generated output.
+    """
+
+    vector_store_id = (
+        linkedin_context.external_known_data.external_openai_vector_store_id
+        if linkedin_context.external_known_data else None
+    )
+
+    if vector_store_id:
+        # Use the vector store if available
+        response_data, status = await get_structured_output_with_assistant_and_vector_store(
+            prompt=prompt,
+            response_format=LinkedInConnectMessage,
+            vector_store_id=vector_store_id,
+            model="gpt-5.1-chat",
+            tool_config=tool_config,
+            use_cache=linkedin_context.message_instructions.use_cache if linkedin_context.message_instructions else True
+        )
+    else:
+        # Otherwise, generate internally
+        response_data, status = await get_structured_output_internal(
+            prompt=prompt,
+            response_format=LinkedInConnectMessage,
+            model="gpt-5.1-chat",
+            tool_config=tool_config,
+            use_cache=linkedin_context.message_instructions.use_cache if linkedin_context.message_instructions else True
+        )
+
+    if status != "SUCCESS":
+        raise Exception("Error: Could not generate the LinkedIn message.")
+
+    # Wrap in MessageItem for consistency
+    response_item = MessageItem(
+        message_id="",  # fill in if you have an ID
+        thread_id="",
+        sender_name=sender_data.sender_full_name or "",
+        sender_email=sender_data.sender_email or "",
+        receiver_name=lead_data.full_name or "",
+        receiver_email=lead_data.email or "",
+        iso_datetime=datetime.utcnow().isoformat(),
+        subject="Hi",
+        body=response_data.body
+    )
+
+    return response_item.model_dump()
+
+# ----------------------------------------------------------------------
+# Primary function to generate multiple LinkedIn message variations
+# (similar to generate_personalized_email)
+# ----------------------------------------------------------------------
+@assistant_tool
+async def generate_personalized_linkedin_message(
+    linkedin_context: ContentGenerationContext,
+    number_of_variations: int = 3,
+    tool_config: Optional[List[Dict]] = None
+) -> List[dict]:
+    """
+    Generate multiple variations of a personalized LinkedIn connection message 
+    using the provided context and instructions.
+
+    :param linkedin_context: Consolidated context for LinkedIn generation
+    :param number_of_variations: Number of variations to produce
+    :param tool_config: Optional config for tool or vector store
+    :return: A list of dictionaries, each containing 'subject' and 'body' only
+    """
+    message_instructions = linkedin_context.message_instructions or MessageGenerationInstructions()
+    user_instructions_exist = bool((message_instructions.instructions_to_generate_message or "").strip())
+
+    linkedin_variations = []
+    
+    for i in range(number_of_variations):
+        # If user provided custom instructions, use them for each variation
+        # Otherwise, pick from fallback frameworks in a round-robin fashion
+        if user_instructions_exist:
+            variation_text = message_instructions.instructions_to_generate_message
+        else:
+            variation_text = LINKEDIN_FRAMEWORK_VARIATIONS[i % len(LINKEDIN_FRAMEWORK_VARIATIONS)]
+        
+        personalized_copy = await generate_personalized_linkedin_copy(
+            linkedin_context=linkedin_context,
+            variation_text=variation_text,
+            tool_config=tool_config
+        )
+        linkedin_variations.append(personalized_copy)
+
+    return linkedin_variations