dhisana 0.0.1.dev32__tar.gz → 0.0.1.dev33__tar.gz

{dhisana-0.0.1.dev32 → dhisana-0.0.1.dev33}/PKG-INFO

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

{dhisana-0.0.1.dev32 → dhisana-0.0.1.dev33}/setup.py

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

{dhisana-0.0.1.dev32 → dhisana-0.0.1.dev33}/src/dhisana/utils/generate_email.py

@@ -27,36 +27,35 @@ async def generate_personalized_email_copy(
     email_context: ContentGenerationContext,
     variation: str,
     tool_config: Optional[List[Dict]] = None
-):
+) -> dict:
     """
     Generate a personalized email copy using provided lead and campaign information with a template.
 
-    This function sends an asynchronous request to generate an email copy based on the provided lead information and template.
-    
-    Parameters:
-    emailcontext: Information about the lead, campaign.
-    tool_config (Optional[List[Dict]]): Configuration for the tool (default is None).
-
-    Returns:
-    dict: The JSON response containing the email subject and body.
-
-    Raises:
-    Exception: If there is an error in processing the request.
+    Steps:
+      1. Use either get_structured_output_with_assistant_and_vector_store or get_structured_output_internal
+         to get a first draft (subject & body).
+      2. If the first draft was generated with 'get_structured_output_with_assistant_and_vector_store',
+         run that draft again through get_structured_output_internal with a refining prompt:
+         
+         "Hi AI Assistant, I have the following draft ready for email, 
+          following is more context for you, refine the email and give me a good output."
+         
+      3. Return the refined version (if step #2 happened) or the original draft (if #2 did not happen).
     """
     cleaned_context = cleanup_email_context(email_context)
-    prompt = f"""
+
+    initial_prompt = f"""
     Hi AI Assistant,
 
     You’re an expert at crafting professional, concise, and compelling emails.
-    Use the details below to ensuring personalization, a clear value proposition,
+    Use the details below to ensure personalization, a clear value proposition,
     and adherence to the specified email template. Avoid spam triggers or irrelevant info.
 
     **Important**: 
     1. The final answer must be a JSON object containing only the fields 'subject' and 'body'.
     2. This is final copy of the email to be sent to the lead directly. DO NOT include any placeholders, comments or instructions in the final output.
-    3. If file_search is provided check if there are any relevant files to help provide more context for email.
+    3. If file_search is provided, check if there are any relevant files to help provide more context for the email.
 
-    
     The attached files have relevant information on case studies, product details, and customer testimonials.
 
     Steps:
@@ -96,25 +95,70 @@ async def generate_personalized_email_copy(
     such as city or school information. DO NOT USE any user identifiers, PII, tracking IDs, internal
     information like deal size, or any other sensitive information in email body generated.
     """
-    
-    if  email_context.external_openai_vector_store_id:
-        response, status = await get_structured_output_with_assistant_and_vector_store(prompt=prompt, 
-                                                                                   response_format=EmailCopy, 
-                                                                                   vector_store_id=email_context.external_openai_vector_store_id, 
-                                                                                   tool_config=tool_config)
-    else:
-        response, status = await get_structured_output_internal(prompt, EmailCopy, tool_config=tool_config)
 
-    if status != 'SUCCESS':
+    # 1. Generate initial draft
+    used_vector_store = False
+    if email_context.external_openai_vector_store_id:
+        # Generate the initial draft with get_structured_output_with_assistant_and_vector_store
+        initial_response, initial_status = await get_structured_output_with_assistant_and_vector_store(
+            prompt=initial_prompt,
+            response_format=EmailCopy,
+            vector_store_id=email_context.external_openai_vector_store_id,
+            tool_config=tool_config
+        )
+        used_vector_store = True
+    else:
+        # Otherwise, generate the initial draft with get_structured_output_internal
+        initial_response, initial_status = await get_structured_output_internal(
+            prompt=initial_prompt,
+            response_format=EmailCopy,
+            tool_config=tool_config
+        )
+
+    if initial_status != 'SUCCESS':
         raise Exception("Error in generating the personalized email.")
-    return response.model_dump()
+
+    # 2. If we used the vector store, refine the draft once more using get_structured_output_internal
+    if used_vector_store:
+        # This is the "second time" prompt that refines the existing draft
+        refine_prompt = f"""
+        Hi AI Assistant, I have following draft ready for email:
+
+        Subject: {initial_response.subject}
+        Body: {initial_response.body}
+
+        Following is more context for you:
+        {cleaned_context.model_dump()}
+
+        Please refine the email and give me a good output.
+        
+        Important:
+          1. The final answer must be a JSON object with 'subject' and 'body' only.
+          2. Keep it concise, professional, and relevant.
+          3. Do not add any placeholders or instructions in the final output.
+        """
+
+        refined_response, refined_status = await get_structured_output_internal(
+            prompt=refine_prompt,
+            response_format=EmailCopy,
+            tool_config=tool_config
+        )
+
+        if refined_status != 'SUCCESS':
+            raise Exception("Error in refining the personalized email.")
+
+        # Return the refined email copy
+        return refined_response.model_dump()
+
+    # 3. Otherwise, just return the initial draft
+    return initial_response.model_dump()
 
 @assistant_tool
 async def generate_personalized_email(
     email_context: ContentGenerationContext,
     number_of_variations: int = 3,
     tool_config: Optional[List[Dict]] = None
-):
+) -> List[dict]:
     """
     Generate a personalized email copy using provided lead and campaign information with a template.
 
@@ -129,22 +173,24 @@ async def generate_personalized_email(
     Raises:
         Exception: If there is an error in processing the request.
     """
+    # Just a few frameworks for demonstration
     variation_specs = [
         "Use PAS (Problem, Agitate, Solve) framework to write up email.",
-        "Use VETO framework (Value, Evidence, Tie, Offer) to compose email.Explain how the product addresses the company’s current goals and requirements.",
+        "Use VETO framework (Value, Evidence, Tie, Offer) to compose email. Explain how the product addresses the company’s current goals and requirements.",
         "Use AIDA framework (Attention, Interest, Desire, Action) to compose email.",
         "Use SPIN (Situation, Problem, Implication, Need-Payoff) framework to write up email.",
         "Use BANT (Budget, Authority, Need, Timeline) framework to write up email.",
-        "Use P-S-B (Pain, Solution, Benefit) framework to write up email."
-        "Use The 3-Bullet Approach (1. Industry Trend or Pain, 2. Value Statement 3. Simple Ask) framework to write up email. Keep it under 100 words."
+        "Use P-S-B (Pain, Solution, Benefit) framework to write up email. Use The 3-Bullet Approach. Keep it under 100 words.",
         "Use Hook, Insight, Offer framework to write up email."
     ]
+
     email_variations = []
     for i in range(number_of_variations):
         try:
+            variation_text = variation_specs[i % len(variation_specs)]
             email_copy = await generate_personalized_email_copy(
                 email_context,
-                variation_specs[i % 3],
+                variation_text,
                 tool_config
             )
             email_variations.append(email_copy)

dhisana-0.0.1.dev33/src/dhisana/utils/generate_structured_output_internal.py

@@ -0,0 +1,205 @@
+import asyncio
+import hashlib
+import json
+import os
+import re
+import time
+import logging
+import uuid
+from typing import Any, Dict, List, Optional, Tuple
+
+from fastapi import HTTPException
+from openai import AsyncOpenAI, OpenAI, OpenAIError, LengthFinishReasonError
+from pydantic import BaseModel, TypeAdapter
+
+from dhisana.utils import cache_output_tools
+from dhisana.utils.openai_assistant_and_file_utils import (
+    add_user_message,
+    create_and_retrieve_run,
+    create_assistant,
+    create_thread,
+    delete_assistant,
+    get_first_message_content,
+    get_run_status,
+)
+from dhisana.utils.openai_helpers import get_openai_access_token
+
+# Instantiate the synchronous OpenAI client (for vector store calls).
+client = OpenAI()
+
+async def get_vector_store_object(vector_store_id: str, tool_config: Optional[List[Dict]] = None) -> Dict:
+    """
+    Retrieve the vector store object (dict) via the SDK.
+    """
+    return await asyncio.to_thread(
+        lambda: client.beta.vector_stores.retrieve(vector_store_id=vector_store_id)
+    )
+
+async def list_vector_store_files(
+    vector_store_id: str,
+    tool_config: Optional[List[Dict]] = None
+) -> List:
+    """
+    Retrieve the list of files (VectorStoreFile objects) for a given vector store.
+    """
+    page = await asyncio.to_thread(
+        lambda: client.beta.vector_stores.files.list(vector_store_id=vector_store_id)
+    )
+    return page.data  # 'data' is the list of VectorStoreFile objects
+
+async def get_structured_output_internal(
+    prompt: str,
+    response_format,
+    tool_config: Optional[List[Dict]] = None
+):
+    """
+    Makes a direct call to the internal structured output approach,
+    bypassing vector store or other chain-of-thought tools.
+    """
+    try:
+        response_type_str = response_format.__name__
+        message_hash = hashlib.md5(prompt.encode('utf-8')).hexdigest()
+        response_type_hash = hashlib.md5(response_type_str.encode('utf-8')).hexdigest()
+        cache_key = f"{message_hash}:{response_type_hash}"
+        cached_response = cache_output_tools.retrieve_output("get_structured_output_internal", cache_key)
+        if cached_response is not None:
+            parsed_cached_response = response_format.parse_raw(cached_response)
+            return parsed_cached_response, 'SUCCESS'
+
+        OPENAI_KEY = get_openai_access_token(tool_config)
+        client_async = AsyncOpenAI(api_key=OPENAI_KEY)
+        completion = await client_async.beta.chat.completions.parse(
+            model="o3-mini",
+            messages=[
+                {"role": "system", "content": "Extract structured content from input. Output is in JSON Format."},
+                {"role": "user", "content": prompt},
+            ],
+            response_format=response_format
+        )
+        response = completion.choices[0].message
+        if response.parsed:
+            cache_output_tools.cache_output(
+                "get_structured_output_internal",
+                cache_key,
+                response.parsed.json()
+            )
+            return response.parsed, 'SUCCESS'
+        elif response.refusal:
+            logging.warning("ERROR: Refusal response: %s", response.refusal)
+            return response.refusal, 'FAIL'
+
+    except LengthFinishReasonError as e:
+        logging.error(f"Too many tokens: {e}")
+        raise HTTPException(status_code=502, detail="The request exceeded the maximum token limit.")
+    except OpenAIError as e:
+        logging.error(f"OpenAI API error: {e}")
+        raise HTTPException(status_code=502, detail="Error communicating with the OpenAI API.")
+    except Exception as e:
+        logging.error(f"Unexpected error: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail="An unexpected error occurred while processing your request."
+        )
+
+async def get_structured_output_with_assistant_and_vector_store(
+    prompt: str,
+    response_format,
+    vector_store_id: str,
+    tool_config: Optional[List[Dict]] = None
+):
+    """
+    If the vector store has NO files, call get_structured_output_internal directly.
+    Otherwise, proceed with the assistant flow.
+    """
+    assistant = None
+    try:
+        # 1. Retrieve the vector store object (to verify it exists or get usage).
+        _ = await get_vector_store_object(vector_store_id, tool_config)
+
+        # 2. Check if the vector store contains any files.
+        files = await list_vector_store_files(vector_store_id, tool_config)
+        if not files:
+            # If no files, just call our internal structured output function.
+            return await get_structured_output_internal(prompt, response_format, tool_config)
+
+        # 3. If there are files, proceed with the assistant-based approach.
+        response_type_str = response_format.__name__
+        message_hash = hashlib.md5(prompt.encode('utf-8')).hexdigest()
+        response_type_hash = hashlib.md5(response_type_str.encode('utf-8')).hexdigest()
+        cache_key = f"{message_hash}:{response_type_hash}"
+        cached_response = cache_output_tools.retrieve_output(
+            "get_structured_output_with_assistant_and_vector_store",
+            cache_key
+        )
+        if cached_response is not None:
+            parsed_cached_response = response_format.parse_raw(cached_response)
+            return parsed_cached_response, 'SUCCESS'
+
+        assistant_name = f"assistant_{uuid.uuid4().hex}"
+        instructions = "Hi, You are a helpful AI Assistant. Help the users with the given instructions."
+        tools = []
+        assistant, vector_store_id = await create_assistant(
+            assistant_name,
+            instructions,
+            tools,
+            vector_store_id,
+            tool_config
+        )
+
+        metadata = {"assistant_id": assistant.id, "assistant_name": assistant_name}
+        thread = await create_thread(metadata, vector_store_id=vector_store_id, tool_config=tool_config)
+        await add_user_message(prompt, thread, tool_config)
+
+        run = await create_and_retrieve_run(
+            thread.id,
+            assistant.id,
+            instructions,
+            tools,
+            response_format,
+            tool_config
+        )
+
+        MAX_WAIT_TIME = 180  # 3 minutes
+        start_time = time.time()
+        while run.status not in ["completed", "failed"]:
+            if time.time() - start_time > MAX_WAIT_TIME:
+                logging.error("Run did not complete within the maximum wait time of 3 minutes.")
+                break
+            await asyncio.sleep(2)
+            run = await get_run_status(thread.id, run.id, tool_config)
+
+        if run.status == 'completed':
+            response_text = await get_first_message_content(thread.id, tool_config)
+            pattern = r'【\d+:\d+†[^】]+】'
+            response_text = re.sub(pattern, '', response_text)
+            if response_text:
+                response = TypeAdapter(response_format).validate_json(response_text)
+                cache_output_tools.cache_output(
+                    "get_structured_output_with_assistant_and_vector_store",
+                    cache_key,
+                    json.dumps(response.model_dump())
+                )
+            else:
+                raise HTTPException(status_code=502, detail="No response from the assistant.")
+            return response, 'SUCCESS'
+        else:
+            raise HTTPException(
+                status_code=502,
+                detail=f"Run failed with status: {run.status}"
+            )
+
+    except LengthFinishReasonError as e:
+        logging.error(f"Too many tokens: {e}")
+        raise HTTPException(status_code=502, detail="The request exceeded the maximum token limit.")
+    except OpenAIError as e:
+        logging.error(f"OpenAI API error: {e}")
+        raise HTTPException(status_code=502, detail="Error communicating with the OpenAI API.")
+    except Exception as e:
+        logging.error(f"Unexpected error: {e}")
+        raise HTTPException(
+            status_code=500,
+            detail="An unexpected error occurred while processing your request."
+        )
+    finally:
+        if assistant:
+            await delete_assistant(assistant.id, tool_config)

{dhisana-0.0.1.dev32 → dhisana-0.0.1.dev33}/src/dhisana/utils/openai_assistant_and_file_utils.py

@@ -242,6 +242,7 @@ async def create_and_retrieve_run(
         instructions=prompt,
         response_format=response_format_schema,
         tools=all_tools,
+        tool_choice={"type": "file_search"}
     )
     return await client.beta.threads.runs.retrieve(thread_id=thread_id, run_id=run.id)
 

{dhisana-0.0.1.dev32 → dhisana-0.0.1.dev33}/src/dhisana.egg-info/PKG-INFO

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

dhisana-0.0.1.dev32/src/dhisana/utils/generate_structured_output_internal.py

@@ -1,139 +0,0 @@
-
-import asyncio
-import hashlib
-import json
-import re
-import time
-import logging
-from typing import Any, Dict, List, Optional, Tuple
-import uuid
-
-from fastapi import HTTPException
-from openai import AsyncOpenAI, OpenAIError, LengthFinishReasonError
-from pydantic import BaseModel, TypeAdapter
-
-from dhisana.utils import cache_output_tools
-from dhisana.utils.openai_assistant_and_file_utils import add_user_message, create_and_retrieve_run, create_assistant, create_thread, delete_assistant, get_first_message_content, get_run_status
-from dhisana.utils.openai_helpers import get_openai_access_token
-
-# Get structutred output based on input message using OpenAI API
-async def get_structured_output_internal(message: str, response_type, tool_config: Optional[List[Dict]] = None):
-    try:
-        # Use the class name instead of serializing the class
-        response_type_str = response_type.__name__
-        
-        # Create unique hashes for message and response_type
-        message_hash = hashlib.md5(message.encode('utf-8')).hexdigest()
-        response_type_hash = hashlib.md5(response_type_str.encode('utf-8')).hexdigest()
-        
-        # Generate the cache key
-        cache_key = f"{message_hash}:{response_type_hash}"
-        cached_response = cache_output_tools.retrieve_output(f"get_structured_output_internal", cache_key)
-        if cached_response is not None:
-            parsed_cached_response = response_type.parse_raw(cached_response)
-            return parsed_cached_response, 'SUCCESS'
-        
-        OPENAI_KEY = get_openai_access_token(tool_config)
-        client = AsyncOpenAI(api_key=OPENAI_KEY)
-        completion = await client.beta.chat.completions.parse(
-            model="o3-mini",
-            messages=[
-                {"role": "system", "content": "Extract structured content from input. Output is in JSON Format."},
-                {"role": "user", "content": message},
-            ],
-            response_format=response_type
-        )
-
-        response = completion.choices[0].message
-        if response.parsed:
-            cache_output_tools.cache_output("get_structured_output_internal", cache_key, response.parsed.json())
-            return response.parsed, 'SUCCESS'
-        elif response.refusal:
-            logging.warning("ERROR: Refusal response: %s", response.refusal)
-            return response.refusal, 'FAIL'
-        
-    except LengthFinishReasonError as e:
-        logging.error(f"Too many tokens: {e}")
-        raise HTTPException(status_code=502, detail="The request exceeded the maximum token limit.")
-    except OpenAIError as e:
-        logging.error(f"OpenAI API error: {e}")
-        raise HTTPException(status_code=502, detail="Error communicating with the OpenAI API.")
-    except Exception as e:
-        logging.error(f"Unexpected error: {e}")
-        raise HTTPException(status_code=500, detail="An unexpected error occurred while processing your request.")
-    
-    
-async def get_structured_output_with_assistant_and_vector_store(prompt: str, response_format, vector_store_id: str, tool_config: Optional[List[Dict]] = None):
-    assistant = None
-    try:
-        # Use the class name instead of serializing the class
-        response_type_str = response_format.__name__
-        
-        # Create unique hashes for message and response_type
-        message_hash = hashlib.md5(prompt.encode('utf-8')).hexdigest()
-        response_type_hash = hashlib.md5(response_type_str.encode('utf-8')).hexdigest()
-        
-        # Generate the cache key
-        cache_key = f"{message_hash}:{response_type_hash}"
-        cached_response = cache_output_tools.retrieve_output(f"get_structured_output_with_assistant_and_vector_store", cache_key)
-        if cached_response is not None:
-            parsed_cached_response = response_format.parse_raw(cached_response)
-            return parsed_cached_response, 'SUCCESS'
-        
-        # Step 1: Create an assistant with the specified vector store attached
-        assistant_name = "assistant_" + uuid.uuid4().hex
-        instructions = "Hi, You are a helpful AI Assistant. Help the users with the given instructions."
-        tools = []
-        assistant, vector_store_id = await create_assistant(assistant_name, instructions, tools, vector_store_id, tool_config)
-
-        # Step 2: Create a new thread with the user's prompt
-        metadata = {"assistant_id": assistant.id, "assistant_name": assistant_name}
-        thread = await create_thread(metadata, vector_store_id=vector_store_id, tool_config=tool_config)
-        
-        message = await add_user_message(prompt, thread, tool_config)
-        tools = []
-
-        # Step 3: Initiate a run with the specified response format
-        run = await create_and_retrieve_run(thread.id, assistant.id, instructions, tools, response_format, tool_config)
-
-        # Step 4: Poll the run status until completion
-        MAX_WAIT_TIME = 180  # 3 minutes in seconds
-        start_time = time.time()
-        while run.status not in ["completed", "failed"]:
-            if time.time() - start_time > MAX_WAIT_TIME:
-                logging.error("Run did not complete within the maximum wait time of 3 minutes.")
-                break
-            await asyncio.sleep(2)
-            run = await get_run_status(thread.id, run.id, tool_config)
-
-        # Step 5: Check if the run completed successfully
-        if run.status == 'completed':
-            # Retrieve the assistant's response
-            response_text = await get_first_message_content(thread.id, tool_config)
-            pattern = r'【\d+:\d+†[^】]+】'
-            response_text = re.sub(pattern, '', response_text)
-            if response_text:
-                response = TypeAdapter(response_format).validate_json(response_text)
-                cache_output_tools.cache_output(
-                    "get_structured_output_with_assistant_and_vector_store",
-                    cache_key,
-                    json.dumps(response.model_dump())
-                )
-            else:
-                raise HTTPException(status_code=502, detail="No response from the assistant.")
-            return response, 'SUCCESS'
-        else:
-            raise HTTPException(status_code=502, detail=f"Run failed with status: {run.status}")
-
-    except LengthFinishReasonError as e:
-        logging.error(f"Too many tokens: {e}")
-        raise HTTPException(status_code=502, detail="The request exceeded the maximum token limit.")
-    except OpenAIError as e:
-        logging.error(f"OpenAI API error: {e}")
-        raise HTTPException(status_code=502, detail="Error communicating with the OpenAI API.")
-    except Exception as e:
-        logging.error(f"Unexpected error: {e}")
-        raise HTTPException(status_code=500, detail="An unexpected error occurred while processing your request.")
-    finally:
-        if assistant:
-            await delete_assistant(assistant.id, tool_config)