dhisana 0.0.1.dev1__tar.gz → 0.0.1.dev2__tar.gz

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/PKG-INFO

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

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/setup.py

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

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/src/dhisana/ui/components.py

@@ -224,11 +224,13 @@ class Tab(Component):
 class ModalDialog(Component):
     def __init__(
         self,
+        name: str,
         title: str,
         content: List[Component],
         visible: bool = False,
         on_close: Optional[str] = None,
     ):
+        self.name = name 
         self.title = title
         self.content = content
         self.visible = visible
@@ -238,6 +240,7 @@ class ModalDialog(Component):
         return {
             'type': 'modal-dialog',
             'properties': {
+                'name': self.name,
                 'title': self.title,
                 'visible': self.visible,
                 'onClose': self.on_close,

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/src/dhisana/utils/agent_tools.py

@@ -23,12 +23,9 @@ from googleapiclient.errors import HttpError
 GLOBAL_DATA_MODELS = []
 GLOBAL_TOOLS_FUNCTIONS = {}
 
+
 @assistant_tool
 async def get_html_content_from_url(url):
-    # Check and replace http with https
-    if url.startswith("http://"):
-        url = url.replace("http://", "https://", 1)
-
     async with async_playwright() as playwright:
         browser = await playwright.chromium.launch(headless=True)
         context = await browser.new_context()
@@ -45,6 +42,7 @@ async def get_html_content_from_url(url):
         finally:
             await browser.close()
 
+
 async def parse_html_content(html_content):
     if not html_content:
         return ""
@@ -53,6 +51,7 @@ async def parse_html_content(html_content):
         element.decompose()
     return soup.get_text(separator=' ', strip=True)
 
+
 def convert_base_64_json(base64_string):
     """
     Convert a base64 encoded string to a JSON string.
@@ -65,12 +64,13 @@ def convert_base_64_json(base64_string):
     """
     # Decode the base64 string to bytes
     decoded_bytes = base64.b64decode(base64_string)
-    
+
     # Convert bytes to JSON string
     json_string = decoded_bytes.decode('utf-8')
-    
+
     return json_string
 
+
 @assistant_tool
 async def get_file_content_from_googledrive_by_name(file_name: str = None) -> str:
     """
@@ -101,12 +101,13 @@ async def get_file_content_from_googledrive_by_name(file_name: str = None) -> st
 
     # Search for the file by name
     query = f"name = '{file_name}'"
-    results = service.files().list(q=query, pageSize=1, fields="files(id, name)").execute()
+    results = service.files().list(q=query, pageSize=1,
+                                   fields="files(id, name)").execute()
     items = results.get('files', [])
 
     if not items:
         raise FileNotFoundError(f"No file found with the name: {file_name}")
-    
+
     # Get the file ID of the first matching file
     file_id = items[0]['id']
     file_name = items[0]['name']
@@ -119,7 +120,7 @@ async def get_file_content_from_googledrive_by_name(file_name: str = None) -> st
 
     # Request the file content from Google Drive
     request = service.files().get_media(fileId=file_id)
-    
+
     # Create a file-like object in memory to hold the downloaded data
     fh = io.FileIO(local_file_path, 'wb')
 
@@ -137,14 +138,15 @@ async def get_file_content_from_googledrive_by_name(file_name: str = None) -> st
     # Return the local file path
     return local_file_path
 
+
 @assistant_tool
-async def write_content_to_googledrive(cloud_file_name: str, local_file_name: str) -> str:
+async def write_content_to_googledrive(cloud_file_path: str, local_file_path: str) -> str:
     """
     Writes content from a local file to a file in Google Drive using a service account.
-    If the file does not exist in Google Drive, it creates it.
+    If the file does not exist in Google Drive, it creates it along with any necessary intermediate directories.
     
-    :param cloud_file_name: The name of the file to create or update on Google Drive.
-    :param local_file_name: The path to the local file whose content will be uploaded.
+    :param cloud_file_path: The path of the file to create or update on Google Drive.
+    :param local_file_path: The path to the local file whose content will be uploaded.
     :return: The file ID of the uploaded or updated file.
     """
 
@@ -167,13 +169,35 @@ async def write_content_to_googledrive(cloud_file_name: str, local_file_name: st
     # Build the Google Drive service object
     service = build('drive', 'v3', credentials=credentials)
 
-    # Check if the file exists in Google Drive
-    query = f"name = '{cloud_file_name}'"
-    results = service.files().list(q=query, pageSize=1, fields="files(id, name)").execute()
-    items = results.get('files', [])
+    # Split the cloud file path into components
+    path_components = cloud_file_path.split('/')
+    parent_id = 'root'
+    
+    # Create intermediate directories if they don't exist
+    for component in path_components[:-1]:
+        query = f"'{parent_id}' in parents and name = '{component}' and mimeType = 'application/vnd.google-apps.folder'"
+        results = service.files().list(q=query, pageSize=1, fields="files(id, name)").execute()
+        items = results.get('files', [])
+        
+        if items:
+            parent_id = items[0]['id']
+        else:
+            file_metadata = {
+                'name': component,
+                'mimeType': 'application/vnd.google-apps.folder',
+                'parents': [parent_id]
+            }
+            folder = service.files().create(body=file_metadata, fields='id').execute()
+            parent_id = folder.get('id')
 
     # Prepare the file for upload
-    media_body = MediaFileUpload(local_file_name, resumable=True)
+    media_body = MediaFileUpload(local_file_path, resumable=True)
+    file_name = path_components[-1]
+
+    # Check if the file exists in the specified directory
+    query = f"'{parent_id}' in parents and name = '{file_name}'"
+    results = service.files().list(q=query, pageSize=1, fields="files(id, name)").execute()
+    items = results.get('files', [])
 
     if items:
         # File exists, update its content
@@ -184,7 +208,10 @@ async def write_content_to_googledrive(cloud_file_name: str, local_file_name: st
         ).execute()
     else:
         # File does not exist, create a new one
-        file_metadata = {'name': cloud_file_name}
+        file_metadata = {
+            'name': file_name,
+            'parents': [parent_id]
+        }
         created_file = service.files().create(
             body=file_metadata,
             media_body=media_body,
@@ -194,8 +221,6 @@ async def write_content_to_googledrive(cloud_file_name: str, local_file_name: st
 
     return file_id
 
-
-
 @assistant_tool
 async def list_files_in_drive_folder_by_name(folder_path: str = None) -> List[str]:
     """
@@ -230,11 +255,13 @@ async def list_files_in_drive_folder_by_name(folder_path: str = None) -> List[st
 
     if folder_path:
         # Split the folder path into individual folder names
-        folder_names = [name for name in folder_path.strip('/').split('/') if name]
+        folder_names = [name for name in folder_path.strip(
+            '/').split('/') if name]
         for folder_name in folder_names:
             # Search for the folder by name under the current folder_id
             query = (
-                f"name = '{folder_name}' and mimeType = 'application/vnd.google-apps.folder' "
+                f"name = '{
+                    folder_name}' and mimeType = 'application/vnd.google-apps.folder' "
                 f"and '{folder_id}' in parents and trashed = false"
             )
             try:
@@ -246,7 +273,7 @@ async def list_files_in_drive_folder_by_name(folder_path: str = None) -> List[st
                 items = results.get('files', [])
                 if not items:
                     raise FileNotFoundError(
-                        f"Folder '{folder_name}' not found under parent folder ID '{folder_id}'"
+                        f"Folder '{folder_name}' not found under parent folder ID '{folder_id}'"                           
                     )
                 # Update folder_id to the ID of the found folder
                 folder_id = items[0]['id']
@@ -424,4 +451,5 @@ async def get_calendar_events_using_service_account_async(
 
     return events
 
-GLOBAL_TOOLS_FUNCTIONS = {name: func for name, func in globals().items() if callable(func) and getattr(func, 'is_assistant_tool', False)}
+GLOBAL_TOOLS_FUNCTIONS = {name: func for name, func in globals().items(
+) if callable(func) and getattr(func, 'is_assistant_tool', False)}

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/src/dhisana/utils/assistant_tool_tag.py

@@ -1,4 +1,4 @@
 # Read API keys from environment variables
 def assistant_tool(func):
     func.is_assistant_tool = True
-    return func
+    return func

dhisana-0.0.1.dev2/src/dhisana/utils/openai_helpers.py

@@ -0,0 +1,485 @@
+# Helper functions to call OpenAI Assistant
+
+from datetime import datetime
+import json
+import asyncio
+from typing import Dict, List
+import logging
+import os
+
+from openai import  OpenAI
+from pydantic import BaseModel
+from fastapi import HTTPException
+from openai import LengthFinishReasonError, OpenAI, OpenAIError
+import csv
+
+
+from .agent_tools import GLOBAL_DATA_MODELS, GLOBAL_TOOLS_FUNCTIONS, get_file_content_from_googledrive_by_name, write_content_to_googledrive
+from .tools_json import GLOBAL_ASSISTANT_TOOLS
+from .openapi_spec_to_tools import (
+    OPENAPI_TOOL_CONFIGURATIONS,
+    OPENAPI_GLOBAL_ASSISTANT_TOOLS,
+    OPENAPI_CALLABALE_FUNCTIONS,
+)
+
+
+async def read_from_google_drive(path):
+    return await get_file_content_from_googledrive_by_name(file_name=path)
+
+# Function to get headers for OpenAPI tools
+def get_headers(toolname):
+    headers = OPENAPI_TOOL_CONFIGURATIONS.get(toolname, {}).get("headers", {})
+    return headers
+
+
+def get_params(toolname):
+    params = OPENAPI_TOOL_CONFIGURATIONS.get(toolname, {}).get("params", {})
+    return params
+
+
+async def run_assistant(client, assistant, thread, prompt, response_type, allowed_tools):
+    """
+    Runs the assistant with the given parameters.
+    """
+    await send_initial_message(client, thread, prompt)
+    allowed_tool_items = get_allowed_tool_items(allowed_tools)
+    response_format = get_response_format(response_type)
+
+    run = client.beta.threads.runs.create_and_poll(
+        thread_id=thread.id,
+        assistant_id=assistant.id,
+        response_format=response_format,
+        tools=allowed_tool_items,
+    )
+
+    max_iterations = 5
+    iteration_count = 0
+
+    while run.status == 'requires_action':
+        if iteration_count >= max_iterations:
+            print("Exceeded maximum number of iterations for requires_action.")
+            return "Error: Exceeded maximum number of iterations for requires_action."
+
+        tool_outputs = await handle_required_action(run)
+        if tool_outputs:
+            run = await submit_tool_outputs(client, thread, run, tool_outputs)
+
+        iteration_count += 1
+
+    return await handle_run_completion(client, thread, run)
+
+
+async def send_initial_message(client, thread, prompt):
+    client.beta.threads.messages.create(
+        thread_id=thread.id,
+        role="user",
+        content=prompt,
+    )
+
+
+def get_allowed_tool_items(allowed_tools):
+    allowed_tool_items = [
+        tool for tool in GLOBAL_ASSISTANT_TOOLS
+        if tool['type'] == 'function' and tool['function']['name'] in allowed_tools
+    ]
+    allowed_tool_items.extend([
+        tool for tool in OPENAPI_GLOBAL_ASSISTANT_TOOLS
+        if tool['type'] == 'function' and tool['function']['name'] in allowed_tools
+    ])
+    return allowed_tool_items
+
+
+def get_response_format(response_type):
+    return {
+        'type': 'json_schema',
+        'json_schema': {
+            "name": response_type.__name__,
+            "schema": response_type.model_json_schema()
+        }
+    }
+
+
+async def handle_required_action(run):
+    tool_outputs = []
+    current_batch_size = 0
+    max_batch_size = 256 * 1024  # 256 KB
+
+    if hasattr(run, 'required_action') and hasattr(run.required_action, 'submit_tool_outputs'):
+        for tool in run.required_action.submit_tool_outputs.tool_calls:
+            function, openai_function = get_function(tool.function.name)
+            if function:
+                output_str, output_size = await invoke_function(function, tool, openai_function)
+                if current_batch_size + output_size > max_batch_size:
+                    tool_outputs.append(
+                        {"tool_call_id": tool.id, "output": ""})
+                else:
+                    tool_outputs.append(
+                        {"tool_call_id": tool.id, "output": output_str})
+                    current_batch_size += output_size
+            else:
+                print(f"Function {tool.function.name} not found.")
+                tool_outputs.append(
+                    {"tool_call_id": tool.id, "output": "No results found"})
+
+    return tool_outputs
+
+
+def get_function(function_name):
+    function = GLOBAL_TOOLS_FUNCTIONS.get(function_name)
+    openai_function = False
+    if not function:
+        function = OPENAPI_CALLABALE_FUNCTIONS.get(function_name)
+        openai_function = True
+    return function, openai_function
+
+
+async def invoke_function(function, tool, openai_function):
+    try:
+        function_args = json.loads(tool.function.arguments)
+        print(f"Invoking function {tool.function.name} with args: {function_args}\n")
+              
+        if openai_function:
+            output = await invoke_openai_function(function, function_args, tool.function.name)
+        else:
+            if asyncio.iscoroutinefunction(function):
+                output = await function(**function_args)
+            else:
+                output = function(**function_args)
+        output_str = json.dumps(output)
+        output_size = len(output_str.encode('utf-8'))
+        print(f"\nOutput from function {tool.function.name}: {output_str[:256]}\n")
+              
+        return output_str, output_size
+    except Exception as e:
+        print(f"Error invoking function {tool.function.name}: {e}")
+        return "No results found", 0
+
+
+async def invoke_openai_function(function, function_args, function_name):
+
+    json_body = function_args.get("json", None)
+    path_params = function_args.get("path_params", None)
+    fn_args = {"path_params": path_params, "data": json_body}
+    headers = get_headers(function_name)
+
+    query_params = function_args.get("params", {})
+    params = get_params(function_name)
+    query_params.update(params)
+    if asyncio.iscoroutinefunction(function):
+        output_fn = await function(
+            name=function_name,
+            fn_args=fn_args,
+            headers=headers,
+            params=query_params,
+        )
+    else:
+        output_fn = function(
+            name=function_name,
+            fn_args=fn_args,
+            headers=headers,
+            params=query_params,
+        )
+    print(f"\nOutput from function {function_name}: {output_fn.status_code} {output_fn.reason}\n")
+    return {
+        "status_code": output_fn.status_code,
+        "text": output_fn.text,
+        "reason": output_fn.reason,
+    }
+
+
+async def submit_tool_outputs(client, thread, run, tool_outputs):
+    try:
+        return client.beta.threads.runs.submit_tool_outputs_and_poll(
+            thread_id=thread.id,
+            run_id=run.id,
+            tool_outputs=tool_outputs
+        )
+    except Exception as e:
+        print("Failed to submit tool outputs:", e)
+        return run
+
+
+async def handle_run_completion(client, thread, run):
+    if run.status == 'completed':
+        messages = client.beta.threads.messages.list(thread_id=thread.id)
+        return messages.data[0].content[0].text.value
+    else:
+        print("Failed to run assistant:", run.status)
+        return run.status
+
+
+async def extract_and_structure_data(client, assistant, thread, prompt, task_inputs, response_type, allowed_tools):
+    # Replace placeholders in the prompt with task inputs
+    formatted_prompt = prompt
+    for key, value in task_inputs.items():
+        placeholder = "{{ inputs." + key + " }}"
+        formatted_prompt = formatted_prompt.replace(placeholder, str(value))
+    output = await run_assistant(client, assistant, thread, formatted_prompt, response_type, allowed_tools)
+    return output
+
+class RowItem(BaseModel):
+    column_value: str
+    
+class ResponseList(BaseModel):
+    rows: List[RowItem]
+    
+def lookup_response_type(name: str):
+    for model in GLOBAL_DATA_MODELS:
+        if model.__name__ == name:
+            return model
+    return ResponseList  # Default response type
+
+
+async def process_agent_request(row_batch: List[Dict], workflow: Dict, custom_instructions: str) -> List[Dict]:
+    """
+    Process agent request using the OpenAI client.
+    """
+    try:
+        client = OpenAI()
+        assistant = client.beta.assistants.create(
+            name="AI Assistant",
+            instructions=f"Hi, You are an AI Assistant. Help the user with their tasks.\n\n{custom_instructions}\n\n",   
+            tools=[],
+            model="gpt-4o-2024-08-06"
+        )
+        thread = client.beta.threads.create()
+
+        parsed_outputs = []
+        for row in row_batch:
+            try:
+                task_outputs = {}  # Dictionary to store outputs of tasks
+                input_list = {}
+                input_list['initial_input_list'] = {
+                    "data": [row],
+                    "format": "list"
+                  }
+                task_outputs['initial_input'] = input_list
+                for task in workflow['tasks']:
+                    # Process each task
+                    task_outputs = await process_task(client, assistant, thread, row, task, task_outputs)
+                # Collect the final output
+                parsed_outputs.append(task_outputs)
+            except Exception as e:
+                print(f"Error processing row {row}: {e}")
+        return parsed_outputs
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return "Error Processing Leads"
+    finally:
+        try:
+            client.beta.assistants.delete(assistant.id)
+        except Exception as e:
+            print(f"Error deleting assistant: {e}")
+
+
+async def process_task(client, assistant, thread, row, task, task_outputs):
+    """
+    Process a single task in the workflow.
+    """
+    try:
+        # Prepare inputs
+        task_inputs = await prepare_task_inputs(row, task, task_outputs)
+
+        # Run the operation
+        output = await run_task_operation(client, assistant, thread, task, task_inputs)
+
+        # Store outputs
+        await store_task_outputs(task, output, task_outputs)
+
+        return task_outputs
+    except Exception as e:
+        print(f"Error processing task {task['id']}: {e}")
+        return task_outputs
+
+async def read_csv_rows(file_path):
+    rows = []
+    with open(file_path, mode='r') as file:
+        csv_reader = csv.reader(file)
+        for row in csv_reader:
+            rows.append(row)
+    return rows
+
+async def prepare_task_inputs(row, task, task_outputs):
+    """
+    Prepare the inputs for a task based on its input specifications.
+    """
+    inputs = task.get('inputs', {})
+    task_inputs = {}
+    for input_name, input_spec in inputs.items():
+        source = input_spec.get('source', {})
+        source_type = source.get('type', '')
+        format = input_spec.get('format', 'list')
+        if source_type == 'external':
+            # External source, get from initial input
+            input_data = row.get(input_name, row)
+        elif source_type == 'task_output':
+            # Get from previous task output
+            task_id = source.get('task_id')
+            output_key = source.get('output_key')
+            previous_task_output = task_outputs.get(task_id, {})
+            print(f"Previous task output: {previous_task_output} Output key: {output_key}")
+            if isinstance(previous_task_output, dict):
+                output_item = previous_task_output.get(output_key)
+                input_data = output_item['data']
+            else:
+                input_data = previous_task_output
+        
+            # Ensure input_data is a list
+            if not isinstance(input_data, list):
+                input_data = [input_data]
+        elif source_type == 'google_drive':
+            # Handle Google Drive source
+            path = source.get('location')
+            input_data_path = await read_from_google_drive(path)
+            input_data = await read_csv_rows(input_data_path)
+        elif source_type == 'local_path':
+            # Handle local path source
+            input_data_path = source.get('location')
+            input_data = await read_csv_rows(input_data_path)
+        else:
+            input_data = None
+        if input_data:
+            task_inputs[input_name] = { 
+                                        "format": format, 
+                                        "data" : input_data
+            }
+    return task_inputs
+
+async def run_task_operation(client, assistant, thread, task, task_inputs):
+    """
+    Execute the operation defined in the task.
+    """
+    operation = task.get('operation', {})
+    operation_type = operation.get('type', '')
+    allowed_tools = operation.get('allowed_tools', [])
+    response_type_name = operation.get('response_type', 'ResponseList')
+    response_type = lookup_response_type(response_type_name)
+    outputs = []
+    
+    if operation_type == 'ai_assistant_call':
+        prompt_template = operation.get('prompt', '')
+        args = operation.get('args', [])
+        # Prepare prompt by substituting inputs
+        
+        formatted_prompt = prompt_template
+        for key, value in task_inputs.items():
+            format = value.get('format', 'list')
+            if format == 'list':
+                for item in value.get('data'):
+                    formatted_prompt = formatted_prompt.replace(
+                        "{{ inputs." + key + " }}", json.dumps(item))
+                    # Run assistant with prompt
+                    output = await extract_and_structure_data(
+                        client, assistant, thread, formatted_prompt, task_inputs, response_type, allowed_tools)
+                    outputs.append(output)
+            else:
+                pass # TODO: Handle other formats
+    elif operation_type == 'python_callable':
+        function_name = operation.get('function', '')
+        args = operation.get('args', [])
+        function = globals().get(function_name)
+        if function is None:
+            raise Exception(f"Function {function_name} not found.")
+        # Prepare function arguments
+        function_args = [task_inputs.get(arg) for arg in args]
+        # Call the function
+        if asyncio.iscoroutinefunction(function):
+            output = await function(*function_args)
+        else:
+            output = function(*function_args)
+        outputs.append(output)
+    else:
+        # Handle other operation types
+        output = None
+    return_val = {
+        "data": outputs,
+        "format": "list"
+    }
+    return return_val
+
+async def store_task_outputs(task, output, task_outputs):
+    """
+    Store the outputs of a task for use in subsequent tasks.
+    """
+    outputs = task.get('outputs', {})
+    if outputs:
+        for output_name, output_spec in outputs.items():
+            # Store output in task_outputs using task id and output_name
+            if task['id'] not in task_outputs:
+                task_outputs[task['id']] = {}
+
+            destination = output_spec.get('destination', {})
+            if destination:
+                dest_type = destination.get('type')
+                path_template = destination.get('path_template')
+                if path_template:
+                    current_timestamp = datetime.now().strftime('%Y%m%d%H%M%S')
+                    path = path_template.replace('{timestamp}', current_timestamp)
+                    path = path.replace('{task_id}', task['id'])
+                    local_path = path
+
+                    if dest_type == 'google_drive':
+                        local_path = os.path.join('/tmp', path)
+
+                    if dest_type == 'google_drive' or dest_type == 'local_path':
+                        directory = os.path.dirname(local_path)
+                        if directory and not os.path.exists(directory):
+                            os.makedirs(directory)
+                        with open(local_path, 'w') as file:
+                            if output.get("format", "") == 'list':
+                                data_list = [json.loads(item) for item in output.get("data", [])]
+                                if data_list:
+                                    # Filter headers to include only simple types
+                                    headers = [key for key, value in data_list[0].items() if isinstance(value, (str, int, float, bool))]
+                                    writer = csv.DictWriter(file, fieldnames=headers)
+                                    writer.writeheader()
+                                    for data in data_list:
+                                        filtered_data = {key: value for key, value in data.items() if key in headers}
+                                        writer.writerow(filtered_data)
+                            else:
+                                file.write(str(output))
+                    else:
+                        # Ignore if destination type is not google_drive or local_path
+                        pass
+
+                if dest_type == 'google_drive':
+                    await write_to_google_drive(path, local_path)
+
+                task_outputs[task['id']][output_name] = output
+    else:
+        # If no outputs are defined, store the output under the task id
+        task_outputs[task['id']] = output
+
+async def write_to_google_drive(cloud_path, local_path):
+    # Placeholder function for writing to Google Drive
+    await write_content_to_googledrive(cloud_path, local_path)
+    print(f"Writing to Google Drive at {cloud_path} {local_path}")
+
+def get_structured_output(message: str, response_type):
+    try:
+        client = OpenAI()
+        completion = client.beta.chat.completions.parse(
+            model="gpt-4o-2024-08-06",
+            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:
+            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.")

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/src/dhisana/utils/openapi_spec_to_tools.py

@@ -12,6 +12,7 @@ OPENAPI_GLOBAL_ASSISTANT_TOOLS = []
 OPENAPI_CALLABALE_FUNCTIONS = {}
 OPENAPI_TOOL_CONFIGURATIONS = {}
 
+
 def convert_spec_to_tools(file_path: str):
     # Open the file and load spec from there
     with open(file_path, 'r') as file:
@@ -20,7 +21,9 @@ def convert_spec_to_tools(file_path: str):
     openai_fns, call_api_fn = openapi_spec_to_openai_fn(spec)
     return openai_fns, call_api_fn
 
-# Parse and save the OpenAI Tools parsed and the corresponding callable functions           
+# Parse and save the OpenAI Tools parsed and the corresponding callable functions
+
+
 def add_openapi_spec_to_tools_list(file_path: str):
     openai_fns, call_api_fn = convert_spec_to_tools(file_path)
     if (len(openai_fns) > 0):
@@ -28,6 +31,5 @@ def add_openapi_spec_to_tools_list(file_path: str):
         for fn in openai_fns:
             name = fn["function"]["name"]
             if name:
-                OPENAPI_CALLABALE_FUNCTIONS[name]= call_api_fn
+                OPENAPI_CALLABALE_FUNCTIONS[name] = call_api_fn
     return OPENAPI_GLOBAL_ASSISTANT_TOOLS
-    

{dhisana-0.0.1.dev1 → dhisana-0.0.1.dev2}/src/dhisana.egg-info/PKG-INFO

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

dhisana-0.0.1.dev1/src/dhisana/utils/openai_helpers.py

@@ -1,272 +0,0 @@
-# Helper functions to call OpenAI Assistant
-
-import logging
-import os
-import json
-from typing import Dict, List
-
-from fastapi import HTTPException
-from openai import LengthFinishReasonError, OpenAI, OpenAIError
-from pydantic import BaseModel
-
-from dhisana.utils.agent_tools import GLOBAL_DATA_MODELS, GLOBAL_TOOLS_FUNCTIONS
-from .tools_json import GLOBAL_ASSISTANT_TOOLS
-from .openapi_spec_to_tools import OPENAPI_TOOL_CONFIGURATIONS, OPENAPI_GLOBAL_ASSISTANT_TOOLS, OPENAPI_CALLABALE_FUNCTIONS
-
-def get_headers(toolname):
-    headers = OPENAPI_TOOL_CONFIGURATIONS.get(toolname, {}).get("headers", {})
-    return headers
-
-def get_params(toolname):
-    headers = OPENAPI_TOOL_CONFIGURATIONS.get(toolname, {}).get("params", {})
-    return headers
-        
-async def run_assistant(client, assistant, thread, prompt, response_type, allowed_tools):
-    """
-    Runs the assistant with the given parameters.
-    """
-    send_initial_message(client, thread, prompt)
-    allowed_tool_items = get_allowed_tool_items(allowed_tools)
-    response_format = get_response_format(response_type)
-
-    run = client.beta.threads.runs.create_and_poll(
-        thread_id=thread.id,
-        assistant_id=assistant.id,
-        response_format=response_format,
-        tools=allowed_tool_items,
-    )
-
-    max_iterations = 5
-    iteration_count = 0
-
-    while run.status == 'requires_action':
-        if iteration_count >= max_iterations:
-            print("Exceeded maximum number of iterations for requires_action.")
-            return "Error: Exceeded maximum number of iterations for requires_action."
-
-        tool_outputs = await handle_required_action(run)
-        if tool_outputs:
-            run = submit_tool_outputs(client, thread, run, tool_outputs)
-
-        iteration_count += 1
-
-    return handle_run_completion(client, thread, run)
-
-
-def send_initial_message(client, thread, prompt):
-    client.beta.threads.messages.create(
-        thread_id=thread.id,
-        role="user",
-        content=prompt,
-    )
-
-
-def get_allowed_tool_items(allowed_tools):
-    allowed_tool_items = [
-        tool for tool in GLOBAL_ASSISTANT_TOOLS 
-        if tool['type'] == 'function' and tool['function']['name'] in allowed_tools
-    ]
-    allowed_tool_items.extend([
-        tool for tool in OPENAPI_GLOBAL_ASSISTANT_TOOLS 
-        if tool['type'] == 'function' and tool['function']['name'] in allowed_tools
-    ])
-    return allowed_tool_items
-
-
-def get_response_format(response_type):
-    return {
-        'type': 'json_schema',
-        'json_schema': {
-            "name": response_type.__class__.__name__,
-            "schema": response_type.model_json_schema()
-        }
-    }
-
-
-async def handle_required_action(run):
-    tool_outputs = []
-    current_batch_size = 0
-    max_batch_size = 256 * 1024
-
-    if hasattr(run, 'required_action') and hasattr(run.required_action, 'submit_tool_outputs'):
-        for tool in run.required_action.submit_tool_outputs.tool_calls:
-            function, openai_function = get_function(tool.function.name)
-            if function:
-                output_str, output_size = await invoke_function(function, tool, openai_function)
-                if current_batch_size + output_size > max_batch_size:
-                    tool_outputs.append({"tool_call_id": tool.id, "output": ""})
-                else:
-                    tool_outputs.append({"tool_call_id": tool.id, "output": output_str})
-                    current_batch_size += output_size
-            else:
-                print(f"Function {tool.function.name} not found.")
-                tool_outputs.append({"tool_call_id": tool.id, "output": "No results found"})
-
-    return tool_outputs
-
-
-def get_function(function_name):
-    function = GLOBAL_TOOLS_FUNCTIONS.get(function_name)
-    openai_function = False
-    if not function:
-        function = OPENAPI_CALLABALE_FUNCTIONS.get(function_name)
-        openai_function = True
-    return function, openai_function
-
-
-async def invoke_function(function, tool, openai_function):
-    try:
-        function_args = json.loads(tool.function.arguments)
-        print(f"Invoking function {tool.function.name} with args: {function_args}\n")
-        if openai_function:
-            output = invoke_openai_function(function, function_args, tool.function.name)
-        else:
-            output = await function(**function_args)
-        output_str = json.dumps(output)
-        output_size = len(output_str.encode('utf-8'))
-        print(f"\nOutput from function {tool.function.name}: {output_str[:64]}\n")        
-        return output_str, output_size
-    except Exception as e:
-        print(f"Error invoking function {tool.function.name}: {e}")
-        return "No results found", 0
-
-
-def invoke_openai_function(function, function_args, function_name):
-    
-    json_body = function_args.get("json", None)
-    path_params = function_args.get("path_params", None)
-    fn_args = {"path_params": path_params, "data": json_body}
-    headers = get_headers(function_name)
-    
-    query_params = function_args.get("params", {})
-    params = get_params(function_name)
-    query_params.update(params)
-
-    output_fn = function(
-        name=function_name,
-        fn_args=fn_args,
-        headers=headers,
-        params=query_params,
-    )
-    print(f"\nOutput from function {function_name}: {output_fn.status_code} {output_fn.reason}\n")
-    return {
-        "status_code": output_fn.status_code,
-        "text": output_fn.text,
-        "reason": output_fn.reason,
-    }
-
-
-def submit_tool_outputs(client, thread, run, tool_outputs):
-    try:
-        return client.beta.threads.runs.submit_tool_outputs_and_poll(
-            thread_id=thread.id,
-            run_id=run.id,
-            tool_outputs=tool_outputs
-        )
-    except Exception as e:
-        print("Failed to submit tool outputs:", e)
-        return run
-
-
-def handle_run_completion(client, thread, run):
-    if run.status == 'completed':
-        messages = client.beta.threads.messages.list(thread_id=thread.id)
-        return messages.data[0].content[0].text.value
-    else:
-        print("Failed to run assistant:", run.status)
-        return run.status
-
-async def extract_and_structure_data(client, assistant, thread, prompt, user_provider_data, response_type, allowed_tools):
-    formatted_prompt = prompt.format(input=user_provider_data)
-    output = await run_assistant(client, assistant, thread, formatted_prompt, response_type, allowed_tools)
-    return output
-
-# Function to get structured output from OpenAI API
-def get_structured_output(message: str, response_type):
-    try:
-        client = OpenAI()
-        completion = client.beta.chat.completions.parse(
-            model="gpt-4o-2024-08-06",
-            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:
-            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.")
-
-class RowItem(BaseModel):
-    column_value: str
-    
-class ResponseList(BaseModel):
-    rows: List[RowItem]
-
-def lookup_response_type(name: str):
-        for model in GLOBAL_DATA_MODELS:
-            if model.__name__ == name:
-                return model
-        return None
-    
-# Function to process a batch request
-async def process_agent_request(row_batch: List[Dict], steps: Dict, custom_instructions: str) -> List[Dict]:
-    """
-    Process agent request using the OpenAI client.
-    """
-    try:
-        client = OpenAI()
-        assistant = client.beta.assistants.create(
-            name="AI Assistant",
-            instructions=f"Hi, You are an AI Assistant. Help the user with their tasks.\n\n{custom_instructions}\n\n",
-            tools=[],
-            model="gpt-4o-2024-08-06"
-        )
-        thread = client.beta.threads.create()
-
-        parsed_outputs = []
-        for row in row_batch:
-            try:
-                input_data = json.dumps(row)
-                output = {}
-                for step in steps['steps']:
-                    type = step.get("response_type", None)
-                    if not type:
-                        type = "ResponseList"
-                        response_type = ResponseList
-                    else:
-                        response_type = lookup_response_type(step.get("response_type", None))                    
-                    if not response_type:
-                        response_type = ResponseList
-                    allowed_tools = step.get("allowed_tools", [])
-                    output = await extract_and_structure_data(client, assistant, thread, step["prompt"], input_data, response_type, allowed_tools)
-                    output_obj = json.loads(output)
-                    if 'ID' in row:
-                        output_obj['INPUT_ID'] = row['ID']
-                    input_data = output
-                parsed_outputs.append(output_obj)
-            except Exception as e:
-                print(f"Error processing lead {row}: {e}")
-        return parsed_outputs
-    except Exception as e:
-        print(f"An error occurred: {e}")
-        return "Error Processing Leads"
-    finally:
-        try:
-            client.beta.assistants.delete(assistant.id)
-        except Exception as e:
-            print(f"Error deleting assistant: {e}")