llumo 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

llumo/exceptions.py

@@ -1,31 +1,45 @@
-class LlumoAPIError(Exception):
-    """Base class for all Llumo SDK-related errors."""
-
-    def __init__(self, message):
-        self.message = message
-        super().__init__(self.message)
-
-    @staticmethod
-    def InvalidApiKey():
-        return LlumoAPIError("The provided API key is invalid or unauthorized")
-
-    @staticmethod
-    def InvalidApiResponse():
-        return LlumoAPIError("Invalid or UnexpectedError response from the API")
-
-    @staticmethod
-    def RequestFailed(detail="The request to the API failed"):
-        return LlumoAPIError(f"Request to the API failed: {detail}")
-
-    @staticmethod
-    def InvalidJsonResponse():
-        return LlumoAPIError("The API response is not in valid JSON format")
-
-    @staticmethod
-    def UnexpectedError(detail="An UnexpectedError error occurred"):
-        return LlumoAPIError(f"UnexpectedError error: {detail}")
-
-    @staticmethod
-    def EvalError(detail="Some error occured while processing"):
-        return LlumoAPIError(f"error: {detail}")
-
+class LlumoAIError(Exception):
+    """Base class for all Llumo SDK-related errors."""
+
+    def __init__(self, message):
+        self.message = message
+        super().__init__(self.message)
+
+    @staticmethod
+    def InvalidApiKey():
+        return LlumoAIError("The provided API key is invalid or unauthorized")
+
+    @staticmethod
+    def InvalidApiResponse():
+        return LlumoAIError("Invalid or UnexpectedError response from the API")
+
+    @staticmethod
+    def RequestFailed(detail="The request to the API failed"):
+        return LlumoAIError(f"Request to the API failed: {detail}")
+
+    @staticmethod
+    def InvalidJsonResponse():
+        return LlumoAIError("The API response is not in valid JSON format")
+
+    @staticmethod
+    def UnexpectedError(detail="An UnexpectedError error occurred"):
+        return LlumoAIError(f"UnexpectedError error: {detail}")
+
+    @staticmethod
+    def EvalError(detail="Some error occured while processing"):
+        return LlumoAIError(f"error: {detail}")
+
+    @staticmethod
+    def InsufficientCredits():
+        return LlumoAIError("LLumo hits exhausted")
+
+    @staticmethod
+    def InvalidPromptTemplate():
+        return LlumoAIError('''Make sure the prompt template fulfills the following criteria:
+        1. All the variables should be inside double curly braces. Example: Give answer for the {{query}}, based on given {{context}}.
+        2. The variables used in the prompt template must be present in the dataframe columns with the same name..
+        ''')
+
+    @staticmethod
+    def modelHitsExhausted(details = "Your credits for the selected model exhausted."):
+        return LlumoAIError(details)

llumo/execution.py

@@ -1,39 +1,39 @@
-import openai
-import google.generativeai as genai
-from .models import Provider
-
-class ModelExecutor:
-    def __init__(self, apiKey: str):
-        self.apiKey = apiKey
-
-    def execute(self, provider: Provider, modelName: str, prompt: str,api_key) -> str:
-        if provider == Provider.OPENAI:
-            return self._executeOpenAI(modelName, prompt,api_key)
-        elif provider == Provider.GOOGLE:
-            return self._executeGoogle(modelName, prompt,api_key)
-        else:
-            raise ValueError(f"Unsupported provider: {provider}")
-
-    def _executeOpenAI(self, modelName: str, prompt: str,api_key) -> str:
-        client = openai.OpenAI(api_key=api_key)
-        response = client.chat.completions.create(model="gpt-4",  # Replace with the desired model
-            messages=[
-                {"role": "system", "content": "You are a helpful assistant."},
-                {"role": "user", "content": prompt}  # User's prompt
-            ]
-        )
-        return response.choices[0].message.content
-
-    def _executeGoogle(self, modelName: str, prompt: str,api_key) -> str:
-        
-        # Configure GenAI with API Key
-        genai.configure(api_key=api_key)
-            
-        # Select Generative Model
-        model = genai.GenerativeModel("gemini-1.5-flash-latest")
-        # Generate Response
-        response = model.generate_content(prompt)
-        return response.text
-        
-    
+import openai
+import google.generativeai as genai
+from .models import Provider
+
+class ModelExecutor:
+    def __init__(self, apiKey: str):
+        self.apiKey = apiKey
+
+    def execute(self, provider: Provider, modelName: str, prompt: str,api_key) -> str:
+        if provider == Provider.OPENAI:
+            return self._executeOpenAI(modelName, prompt,api_key)
+        elif provider == Provider.GOOGLE:
+            return self._executeGoogle(modelName, prompt,api_key)
+        else:
+            raise ValueError(f"Unsupported provider: {provider}")
+
+    def _executeOpenAI(self, modelName: str, prompt: str,api_key) -> str:
+        client = openai.OpenAI(api_key=api_key)
+        response = client.chat.completions.create(model="gpt-4",  # Replace with the desired model
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant."},
+                {"role": "user", "content": prompt}  # User's prompt
+            ]
+        )
+        return response.choices[0].message.content
+
+    def _executeGoogle(self, modelName: str, prompt: str,api_key) -> str:
+        
+        # Configure GenAI with API Key
+        genai.configure(api_key=api_key)
+            
+        # Select Generative Model
+        model = genai.GenerativeModel("gemini-2.0-flash-lite")
+        # Generate Response
+        response = model.generate_content(prompt)
+        return response.text
+        
+    
  

llumo/functionCalling.py

@@ -0,0 +1,189 @@
+import os
+import json
+import pandas as pd
+from typing import Callable, List, Dict
+from dotenv import load_dotenv
+import google.generativeai as genai
+from google.generativeai.types import FunctionDeclaration, Tool
+from openai import OpenAI
+from .exceptions import *
+# Load environment variables
+load_dotenv()
+# openai_api = os.getenv("OPENAI_API_KEY")
+# google_api_key = os.getenv("GOOGLE_API_KEY")
+
+
+class LlumoAgent:
+    def __init__(self, name: str, description: str, parameters: Dict, function: Callable):
+        self.name = name
+        self.description = description
+        self.parameters = parameters
+        self.function = function
+
+    def run(self, **kwargs):
+        return self.function(**kwargs)
+
+    def createGoogleTool(self):
+        return FunctionDeclaration(
+            name=self.name,
+            description=self.description,
+            parameters={
+                "type": "object",
+                "properties": self.parameters,
+                "required": list(self.parameters.keys())
+            }
+        )
+
+    def createOpenaiTool(self):
+        return {
+            "type": "function",
+            "function": {
+                "name": self.name,
+                "description": self.description,
+                "parameters": {
+                    "type": "object",
+                    "properties": self.parameters,
+                    "required": list(self.parameters.keys()),
+                }
+            }
+        }
+
+
+class LlumoAgentExecutor:
+
+    @staticmethod
+    def run(df: pd.DataFrame, agents: List[LlumoAgent], model: str,model_api_key = None):
+        if model.lower() == "google":
+            return LlumoAgentExecutor.runWithGoogle(df, agents,model_api_key = model_api_key)
+        elif model.lower() == "openai":
+            return LlumoAgentExecutor.runWithOpenAI(df, agents,model_api_key = model_api_key)
+        else:
+            raise ValueError(f"Unsupported model: {model}. Use 'google' or 'openai'.")
+
+
+    @staticmethod
+    def runWithGoogle(df: pd.DataFrame, agents: List[LlumoAgent],model_api_key = None):
+        try:
+            genai.configure(api_key=model_api_key)
+            tool_defs = []
+            func_lookup = {}
+            for agent in agents:
+                tool_defs.append(agent.createGoogleTool())
+                func_lookup[agent.name] = agent
+
+            tool_wrapper = Tool(function_declarations=tool_defs)
+            model = genai.GenerativeModel("gemini-1.5-pro", tools=[tool_wrapper])
+
+            results = []
+            histories = []
+
+            for _, row in df.iterrows():
+                try:
+                    query = row["query"]
+                    chat = model.start_chat()
+                    response = chat.send_message(query)
+                    parts = response.candidates[0].content.parts
+                    final_output = ""
+
+                    for part in parts:
+                        if hasattr(part, "function_call") and part.function_call:
+                            func_call = part.function_call
+                            agent = func_lookup.get(func_call.name)
+                            result = agent.run(**(func_call.args or {}))
+
+                            follow_up_msg = {
+                                "function_response": {
+                                    "name": func_call.name,
+                                    "response": result
+                                }
+                            }
+
+                            follow_up_response = chat.send_message(follow_up_msg)
+                            final_output = follow_up_response.text
+                        else:
+                            final_output = part.text
+
+                    results.append(final_output)
+                    histories.append(str(chat.history))
+                except Exception as e:
+                    raise LlumoAIError.modelHitsExhausted()
+                    # results.append(f"Error during processing: {e}")
+                    # histories.append("Error in conversation")
+
+            df["output"] = results
+            df["messageHistory"] = histories
+            df["tools"] = str({a.name: a.description for a in agents})
+            return df
+
+        except Exception as e:
+            raise RuntimeError(f"Error in runWithGoogle: {e}")
+
+    @staticmethod
+    def runWithOpenAI(df: pd.DataFrame, agents: List[LlumoAgent],model_api_key = None):
+        try:
+            client = OpenAI(api_key=model_api_key)
+            all_tools = [agent.createOpenaiTool() for agent in agents]
+            agent_lookup = {agent.name: agent for agent in agents}
+
+            results = []
+            messageHistories = []
+
+            for _, row in df.iterrows():
+                try:
+                    query = row["query"]
+                    messages = [{"role": "user", "content": query}]
+
+                    initial_response = client.chat.completions.create(
+                        model="gpt-4",
+                        messages=messages,
+                        tools=all_tools,
+                        tool_choice="auto"
+                    )
+
+                    first_message = initial_response.choices[0].message
+                    assistant_msg = {"role": "assistant"}
+
+                    if first_message.content:
+                        assistant_msg["content"] = first_message.content
+                    if first_message.tool_calls:
+                        assistant_msg["tool_calls"] = first_message.tool_calls
+
+                    messages.append(assistant_msg)
+
+                    if first_message.tool_calls:
+                        for call in first_message.tool_calls:
+                            tool_name = call.function.name
+                            args = json.loads(call.function.arguments)
+                            agent = agent_lookup[tool_name]
+                            tool_result = agent.run(**args)
+
+                            messages.append({
+                                "role": "tool",
+                                "tool_call_id": call.id,
+                                "content": str(tool_result)
+                            })
+
+                        final_response = client.chat.completions.create(
+                            model="gpt-4",
+                            messages=messages
+                        )
+                        final_output = final_response.choices[0].message.content
+                        messages.append({"role": "assistant", "content": final_output})
+                    else:
+                        final_output = first_message.content
+
+                    results.append(final_output)
+                    messageHistories.append(str(messages))
+
+                except Exception as e:
+                    results.append(f"Error during processing: {e}")
+                    messageHistories.append("Error in conversation")
+
+            df["output"] = results
+            df["messageHistory"] = messageHistories
+            df["tools"] = str({a.name: a.description for a in agents})
+            return df
+
+        except Exception as e:
+            raise RuntimeError(f"Error in runWithOpenAI: {e}")
+

llumo/helpingFuntions.py

@@ -1,60 +1,50 @@
-import time
-import uuid
-
-def getProcessID():
-    return f"{int(time.time() * 1000)}{uuid.uuid4()}"
-
-
-def getInputPopulatedPrompt(promptTemplate, tempObj):
-    for key, value in tempObj.items():
-        promptTemplate = promptTemplate.replace(f"{{{{{key}}}}}", value)
-    return promptTemplate
-
-
-
-import time
-import uuid
-
-def getProcessID():
-    return f"{int(time.time() * 1000)}{uuid.uuid4()}"
-
-
-def getInputPopulatedPrompt(promptTemplate, tempObj):
-    for key, value in tempObj.items():
-        promptTemplate = promptTemplate.replace(f"{{{{{key}}}}}", value)
-    return promptTemplate
-
-def costColumnMapping(costResults,allProcess):
-    # this dict will store cost column data for each row
-    cost_cols = {}
-    compressed_prompt = []
-    compressed_prompt_output = []
-    cost = []
-    cost_saving = []
-    print("BATCHES: ",allProcess)
-    print("COST RESULTS :", costResults)
-    # iterate through each batch
-    for record in allProcess:
-        cost_cols[record] = []
-        # iterate through each record of cost saving results received from the api
-        for item in costResults:
-            # fetching all cost column data for a specific row. i.e each row will have 4 columns
-            if list(item.keys())[0].split("-")[0] == record.split("-")[0]:
-                cost_cols[record].append(list(item.values())[0])
-
-    for ky, val in cost_cols.items():
-        # compressed prompt column
-        compressed_prompt.append(val[0])
-        # compressed output
-        compressed_prompt_output.append(val[1])
-        # cost
-        cost.append(val[2])
-        # cost saved
-        cost_saving.append(val[3])
-
-    return compressed_prompt , compressed_prompt_output  , cost , cost_saving
-
-
-
-
-
+import time
+import uuid
+import numpy as np
+
+def getProcessID():
+    return f"{int(time.time() * 1000)}{uuid.uuid4()}"
+
+
+def getInputPopulatedPrompt(promptTemplate, tempObj):
+    for key, value in tempObj.items():
+        promptTemplate = promptTemplate.replace(f"{{{{{key}}}}}", value)
+    return promptTemplate
+
+def costColumnMapping(costResults, allProcess):
+    # this dict will store cost column data for each row
+    cost_cols = {}
+
+    compressed_prompt = []
+    compressed_prompt_output = []
+    cost = []
+    cost_saving = []
+
+    for record in allProcess:
+        cost_cols[record] = []
+        for item in costResults:
+            if list(item.keys())[0].split("-")[0] == record.split("-")[0]:
+                cost_cols[record].append(list(item.values())[0])
+
+    for ky, val in cost_cols.items():
+        try:
+            compressed_prompt.append(val[0])
+        except IndexError:
+            compressed_prompt.append("error occured")
+
+        try:
+            compressed_prompt_output.append(val[1])
+        except IndexError:
+            compressed_prompt_output.append("error occured")
+
+        try:
+            cost.append(val[2])
+        except IndexError:
+            cost.append("error occured")
+
+        try:
+            cost_saving.append(val[3])
+        except IndexError:
+            cost_saving.append("error occured")
+
+    return compressed_prompt, compressed_prompt_output, cost, cost_saving

llumo/models.py

@@ -1,43 +1,43 @@
-from enum import Enum
-
-class Provider(str, Enum):
-    OPENAI = "OPENAI"
-    GOOGLE = "GOOGLE"
-
-# Maps model aliases → (provider, actual model name for API)
-_MODEL_METADATA = {
-    "GPT_4": (Provider.OPENAI, "gpt-4"),
-    "GPT_4_32K": (Provider.OPENAI, "gpt-4-32k"),
-    "GPT_35T": (Provider.OPENAI, "gpt-3.5-turbo"),
-    "GPT_35T_INS": (Provider.OPENAI, "gpt-3.5-turbo-instruct"),
-    "GPT_35T_16K": (Provider.OPENAI, "gpt-3.5-turbo-16k"),
-    "GPT_35_TURBO": (Provider.OPENAI, "gpt-3.5-turbo"),
-
-    "GOOGLE_15_FLASH": (Provider.GOOGLE, "gemini-1.5-flash-latest"),
-    "GEMINI_PRO": (Provider.GOOGLE, "gemini-pro"),
-    "TEXT_BISON": (Provider.GOOGLE, "text-bison-001"),
-    "CHAT_BISON": (Provider.GOOGLE, "chat-bison-001"),
-    "TEXT_BISON_32K": (Provider.GOOGLE, "text-bison-32k"),
-    "TEXT_UNICORN": (Provider.GOOGLE, "text-unicorn-experimental"),
-}
-
-class AVAILABLEMODELS(str, Enum):
-    GPT_4 = "gpt-4"
-    GPT_4_32K = "gpt-4-32k"
-    GPT_35T = "gpt-3.5-turbo"
-    GPT_35T_INS = "gpt-3.5-turbo-instruct"
-    GPT_35T_16K = "gpt-3.5-turbo-16k"
-    GPT_35_TURBO = "gpt-3.5-turbo"
-
-    GOOGLE_15_FLASH = "gemini-1.5-flash-latest"
-    GEMINI_PRO = ""
-    TEXT_BISON = "text-bison-001"
-    CHAT_BISON = "chat-bison-001"
-    TEXT_BISON_32K = "text-bison-32k"
-    TEXT_UNICORN = "text-unicorn-experimental"
-
-def getProviderFromModel(model: AVAILABLEMODELS) -> Provider:
-    for alias, (provider, apiName) in _MODEL_METADATA.items():
-        if model.value == apiName:
-            return provider
+from enum import Enum
+
+class Provider(str, Enum):
+    OPENAI = "OPENAI"
+    GOOGLE = "GOOGLE"
+
+# Maps model aliases → (provider, actual model name for API)
+_MODEL_METADATA = {
+    "GPT_4": (Provider.OPENAI, "gpt-4"),
+    "GPT_4_32K": (Provider.OPENAI, "gpt-4-32k"),
+    "GPT_35T": (Provider.OPENAI, "gpt-3.5-turbo"),
+    "GPT_35T_INS": (Provider.OPENAI, "gpt-3.5-turbo-instruct"),
+    "GPT_35T_16K": (Provider.OPENAI, "gpt-3.5-turbo-16k"),
+    "GPT_35_TURBO": (Provider.OPENAI, "gpt-3.5-turbo"),
+
+    "GOOGLE_15_FLASH": (Provider.GOOGLE, "gemini-1.5-flash-latest"),
+    "GEMINI_PRO": (Provider.GOOGLE, "gemini-pro"),
+    "TEXT_BISON": (Provider.GOOGLE, "text-bison-001"),
+    "CHAT_BISON": (Provider.GOOGLE, "chat-bison-001"),
+    "TEXT_BISON_32K": (Provider.GOOGLE, "text-bison-32k"),
+    "TEXT_UNICORN": (Provider.GOOGLE, "text-unicorn-experimental"),
+}
+
+class AVAILABLEMODELS(str, Enum):
+    GPT_4 = "gpt-4"
+    GPT_4_32K = "gpt-4-32k"
+    GPT_35T = "gpt-3.5-turbo"
+    GPT_35T_INS = "gpt-3.5-turbo-instruct"
+    GPT_35T_16K = "gpt-3.5-turbo-16k"
+    GPT_35_TURBO = "gpt-3.5-turbo"
+
+    GOOGLE_15_FLASH = "gemini-1.5-flash-latest"
+    GEMINI_PRO = ""
+    TEXT_BISON = "text-bison-001"
+    CHAT_BISON = "chat-bison-001"
+    TEXT_BISON_32K = "text-bison-32k"
+    TEXT_UNICORN = "text-unicorn-experimental"
+
+def getProviderFromModel(model: AVAILABLEMODELS) -> Provider:
+    for alias, (provider, apiName) in _MODEL_METADATA.items():
+        if model.value == apiName:
+            return provider
     raise ValueError(f"Provider not found for model: {model}")