llumo 0.1.6b2__py3-none-any.whl → 0.1.6b3__py3-none-any.whl

llumo/exceptions.py

@@ -1,45 +1,45 @@
-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."):
+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-2.0-flash-lite")
-        # 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

@@ -1,189 +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}")
-
+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,50 +1,50 @@
-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
+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