llumo 0.2.0__py3-none-any.whl → 0.2.2__py3-none-any.whl

llumo/client.py

@@ -1,18 +1,16 @@
 import requests
-from docutils.nodes import subscript
 
 from .exceptions import LlumoAIError
 import time
 import re
 import json
 import uuid
-import threading
 from dotenv import load_dotenv
 import os
 import itertools
 import pandas as pd
 from typing import List, Dict
-from .models import AVAILABLEMODELS,getProviderFromModel
+from .models import AVAILABLEMODELS, getProviderFromModel
 from .execution import ModelExecutor
 from .helpingFuntions import *
 from .sockets import LlumoSocketClient
@@ -20,13 +18,15 @@ from .functionCalling import LlumoAgentExecutor
 
 
 # 👇 NEW: Explicitly load .env from the package folder
-envPath = os.path.join(os.path.dirname(__file__), '.env')
-load_dotenv(dotenv_path=envPath, override=False)# Automatically looks for .env in current directory
+envPath = os.path.join(os.path.dirname(__file__), ".env")
+load_dotenv(
+    dotenv_path=envPath, override=False
+)  # Automatically looks for .env in current directory
 
-postUrl = os.getenv("POST_URL")
-fetchUrl = os.getenv("FETCH_URL")
-validateUrl = os.getenv("VALIDATE_URL")
-socketUrl = os.getenv("SOCKET_URL")
+postUrl = "https://app.llumo.ai/api/eval/run-multiple-column"
+fetchUrl = "https://app.llumo.ai/api/eval/fetch-rows-data-by-column"
+validateUrl = "https://app.llumo.ai/api/workspace-details"
+socketUrl = "https://red-skull-service-392377961931.us-central1.run.app/"
 
 
 class LlumoClient:
@@ -35,27 +35,17 @@ class LlumoClient:
         self.apiKey = api_key
         self.socket = LlumoSocketClient(socketUrl)
         self.processMapping = {}
-        
 
-
-    def validateApiKey(self, evalName = ""):
+    def validateApiKey(self, evalName=""):
         headers = {
             "Authorization": f"Bearer {self.apiKey}",
             "Content-Type": "application/json",
         }
         reqBody = {"analytics": [evalName]}
 
-        # print(f"Making API key validation request to: {validateUrl}")
-        # print(f"Request body: {reqBody}")
-
         try:
             response = requests.post(url=validateUrl, json=reqBody, headers=headers)
-            # print(response.text)
-            # Print response info for debugging
-            # print(f"Response status code: {response.status_code}")
-            # print(f"Response headers: {response.headers}")
 
-            # Try to get at least some of the response content
             try:
                 response_preview = response.text[:500]  # First 500 chars
                 # print(f"Response preview: {response_preview}")
@@ -75,11 +65,6 @@ class LlumoClient:
                 detail=f"Endpoint not found (404): {validateUrl}"
             )
 
-        # if response.status_code >= 500:
-        #     raise LlumoAIError.ServerError(
-        #         detail=f"Server error ({response.status_code})"
-        #     )
-
         if response.status_code != 200:
             raise LlumoAIError.RequestFailed(
                 detail=f"Unexpected status code: {response.status_code}"
@@ -102,14 +87,10 @@ class LlumoClient:
             self.workspaceID = data["data"].get("workspaceID")
             self.evalDefinition = data["data"].get("analyticsMapping")
             self.socketToken = data["data"].get("token")
-            self.hasSubscribed = data["data"].get("hasSubscribed",False)
-            self.trialEndDate = data["data"].get("trialEndDate",None)
+            self.hasSubscribed = data["data"].get("hasSubscribed", False)
+            self.trialEndDate = data["data"].get("trialEndDate", None)
             self.subscriptionEndDate = data["data"].get("subscriptionEndDate", None)
-
-            # print(f"API key validation successful:")
-            # print(f"- Remaining hits: {self.hitsAvailable}")
-            # print(f"- Workspace ID: {self.workspaceID}")
-            # print(f"- Token received: {'Yes' if self.socketToken else 'No'}")
+            self.email = data["data"].get("email", None)
 
         except Exception as e:
             # print(f"Error extracting data from response: {str(e)}")
@@ -134,7 +115,6 @@ class LlumoClient:
 
         except Exception as e:
             print(f"Error in posting batch: {e}")
-    
 
     def postDataStream(self, batch, workspaceID):
         payload = {
@@ -155,31 +135,36 @@ class LlumoClient:
 
         except Exception as e:
             print(f"Error in posting batch: {e}")
-    
 
     def AllProcessMapping(self):
         for batch in self.allBatches:
             for record in batch:
-                rowId = record['rowID']
-                colId = record['columnID']
-                pid = f'{rowId}-{colId}-{colId}'
+                rowId = record["rowID"]
+                colId = record["columnID"]
+                pid = f"{rowId}-{colId}-{colId}"
                 self.processMapping[pid] = record
 
-
-    def finalResp(self,results):
+    def finalResp(self, results):
         seen = set()
         uniqueResults = []
 
         for item in results:
             for rowID in item:  # Each item has only one key
-            # for rowID in item["data"]:
+                # for rowID in item["data"]:
                 if rowID not in seen:
                     seen.add(rowID)
                     uniqueResults.append(item)
 
         return uniqueResults
 
-    def evaluate(self, dataframe, eval ="Response Completeness", prompt_template="", outputColName="output"):
+    def evaluate(
+        self,
+        dataframe,
+        eval="Response Completeness",
+        prompt_template="",
+        outputColName="output",
+        createExperiment: bool = False,
+    ):
 
         results = {}
         try:
@@ -192,11 +177,12 @@ class LlumoClient:
                 time.sleep(0.1)
                 waited_secs += 0.1
                 if waited_secs >= max_wait_secs:
-                    raise RuntimeError("Timeout waiting for server 'connection-established' event.")
+                    raise RuntimeError(
+                        "Timeout waiting for server 'connection-established' event."
+                    )
 
             rowIdMapping = {}
 
-
             print(f"\n======= Running evaluation for: {eval} =======")
 
             try:
@@ -205,8 +191,14 @@ class LlumoClient:
                 if hasattr(e, "response") and getattr(e, "response", None) is not None:
                     pass
                 raise
-            userHits = checkUserHits(self.workspaceID,self.hasSubscribed,self.trialEndDate,self.subscriptionEndDate,self.hitsAvailable,len(dataframe))
-
+            userHits = checkUserHits(
+                self.workspaceID,
+                self.hasSubscribed,
+                self.trialEndDate,
+                self.subscriptionEndDate,
+                self.hitsAvailable,
+                len(dataframe),
+            )
 
             if not userHits["success"]:
                 raise LlumoAIError.InsufficientCredits(userHits["message"])
@@ -219,14 +211,21 @@ class LlumoClient:
             provider = "OPENAI"
             evalType = "LLM"
             workspaceID = self.workspaceID
+            email = self.email
 
             self.allBatches = []
             currentBatch = []
 
             for index, row in dataframe.iterrows():
                 tools = [row["tools"]] if "tools" in dataframe.columns else []
-                groundTruth = row["groundTruth"] if "groundTruth" in dataframe.columns else ""
-                messageHistory = [row["messageHistory"]] if "messageHistory" in dataframe.columns else []
+                groundTruth = (
+                    row["groundTruth"] if "groundTruth" in dataframe.columns else ""
+                )
+                messageHistory = (
+                    [row["messageHistory"]]
+                    if "messageHistory" in dataframe.columns
+                    else []
+                )
                 promptTemplate = prompt_template
 
                 keys = re.findall(r"{{(.*?)}}", promptTemplate)
@@ -235,9 +234,13 @@ class LlumoClient:
                     raise LlumoAIError.InvalidPromptTemplate()
 
                 inputDict = {key: row[key] for key in keys if key in row}
-                output = row[outputColName] if outputColName in dataframe.columns else ""
+                output = (
+                    row[outputColName] if outputColName in dataframe.columns else ""
+                )
 
-                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
+                    "-", ""
+                )
                 rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
                 columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
 
@@ -270,6 +273,7 @@ class LlumoClient:
                     "rowID": rowID,
                     "playgroundID": activePlayground,
                     "processType": "EVAL",
+                    "email": email,
                 }
 
                 query = ""
@@ -282,7 +286,9 @@ class LlumoClient:
                         else:
                             if promptTemplate:
                                 tempObj = {key: value}
-                                promptTemplate = getInputPopulatedPrompt(promptTemplate, tempObj)
+                                promptTemplate = getInputPopulatedPrompt(
+                                    promptTemplate, tempObj
+                                )
                             else:
                                 query += f" {key}: {value}, "
 
@@ -290,11 +296,17 @@ class LlumoClient:
                     for key, value in inputDict.items():
                         context += f" {key}: {value}, "
 
-                templateData["processData"]["executionDependency"]["context"] = context.strip()
-                templateData["processData"]["executionDependency"]["query"] = query.strip()
+                templateData["processData"]["executionDependency"][
+                    "context"
+                ] = context.strip()
+                templateData["processData"]["executionDependency"][
+                    "query"
+                ] = query.strip()
 
                 if promptTemplate and not query.strip():
-                    templateData["processData"]["executionDependency"]["query"] = promptTemplate
+                    templateData["processData"]["executionDependency"][
+                        "query"
+                    ] = promptTemplate
 
                 currentBatch.append(templateData)
 
@@ -316,7 +328,10 @@ class LlumoClient:
             timeout = max(50, min(600, totalItems * 10))
 
             self.socket.listenForResults(
-                min_wait=40, max_wait=timeout, inactivity_timeout=150, expected_results=totalItems
+                min_wait=40,
+                max_wait=timeout,
+                inactivity_timeout=150,
+                expected_results=totalItems,
             )
 
             eval_results = self.socket.getReceivedData()
@@ -334,26 +349,33 @@ class LlumoClient:
             dataframe[evalName] = None
             for item in records:
                 for compound_key, value in item.items():
-                # for compound_key, value in item['data'].items():
+                    # for compound_key, value in item['data'].items():
 
-                    rowID = compound_key.split('-')[0]
+                    rowID = compound_key.split("-")[0]
                     # looking for the index of each rowID , in the original dataframe
                     if rowID in rowIdMapping:
                         index = rowIdMapping[rowID]
                         # dataframe.at[index, evalName] = value
                         dataframe.at[index, evalName] = value["value"]
-                        dataframe.at[index, f'{evalName} Reason'] = value["reasoning"]
-
+                        dataframe.at[index, f"{evalName} Reason"] = value["reasoning"]
 
                     else:
                         pass
                         # print(f"⚠️ Warning: Could not find rowID {rowID} in mapping")
+        if createExperiment:
+            pd.set_option("future.no_silent_downcasting", True)
+            df = dataframe.fillna("Some error occured").astype(object)
 
-        return dataframe
+            if createPlayground(email, workspaceID, df):
+                print(
+                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                )
+        else:
+            return dataframe
 
     def evaluateCompressor(self, dataframe, prompt_template):
         results = []
-        
+
         try:
             # Connect to socket first
             # print("Connecting to socket server...")
@@ -366,7 +388,9 @@ class LlumoClient:
                 time.sleep(0.1)
                 waited_secs += 0.1
                 if waited_secs >= max_wait_secs:
-                    raise RuntimeError("Timeout waiting for server 'connection-established' event.")
+                    raise RuntimeError(
+                        "Timeout waiting for server 'connection-established' event."
+                    )
 
             # print(f"Connected with socket ID: {socketID}")
 
@@ -382,10 +406,16 @@ class LlumoClient:
                 raise
 
             # check for available hits and trial limit
-            userHits = checkUserHits(self.workspaceID, self.hasSubscribed, self.trialEndDate, self.subscriptionEndDate,
-                                     self.hitsAvailable, len(dataframe))
+            userHits = checkUserHits(
+                self.workspaceID,
+                self.hasSubscribed,
+                self.trialEndDate,
+                self.subscriptionEndDate,
+                self.hitsAvailable,
+                len(dataframe),
+            )
 
-           # do not proceed if subscription or trial limit has exhausted
+            # do not proceed if subscription or trial limit has exhausted
             if not userHits["success"]:
                 raise LlumoAIError.InsufficientCredits(userHits["message"])
 
@@ -396,7 +426,7 @@ class LlumoClient:
             provider = "OPENAI"
             evalType = "LLUMO"
             workspaceID = self.workspaceID
-
+            email = self.email
             # Prepare all batches before sending
             # print("Preparing batches...")
             self.allBatches = []
@@ -412,14 +442,22 @@ class LlumoClient:
                 if not all([ky in dataframe.columns for ky in keys]):
                     raise LlumoAIError.InvalidPromptTemplate()
 
-                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
+                    "-", ""
+                )
                 rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
                 columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
 
-                compressed_prompt_id = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
-                compressed_prompt_output_id = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                compressed_prompt_id = (
+                    f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                )
+                compressed_prompt_output_id = (
+                    f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                )
                 cost_id = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
-                cost_saving_id = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                cost_saving_id = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
+                    "-", ""
+                )
 
                 # Use the server-provided socket ID here
                 templateData = {
@@ -435,7 +473,7 @@ class LlumoClient:
                         "compressed_prompt": compressed_prompt_id,
                         "compressed_prompt_output": compressed_prompt_output_id,
                         "cost": cost_id,
-                        "cost_saving": cost_saving_id
+                        "cost_saving": cost_saving_id,
                     },
                     "processData": {
                         "rowData": {
@@ -451,15 +489,14 @@ class LlumoClient:
                             "compressed_prompt": compressed_prompt_id,
                             "compressed_prompt_output": compressed_prompt_output_id,
                             "cost": cost_id,
-                            "cost_saving": cost_saving_id
-                        }
+                            "cost_saving": cost_saving_id,
+                        },
                     },
                     "workspaceID": workspaceID,
-                    "email": "",
-                    "playgroundID": activePlayground
+                    "email": email,
+                    "playgroundID": activePlayground,
                 }
 
-
                 # Build query/context from input
                 query = ""
                 context = ""
@@ -471,7 +508,9 @@ class LlumoClient:
                             context += f" {key}: {value}, "
                         else:
                             if promptTemplate:
-                                populatedPrompt = getInputPopulatedPrompt(promptTemplate, {key: value})
+                                populatedPrompt = getInputPopulatedPrompt(
+                                    promptTemplate, {key: value}
+                                )
                                 query += f"{populatedPrompt} "
                             else:
                                 query += f" {key}: {value}, "
@@ -480,18 +519,22 @@ class LlumoClient:
                     for key, value in inputDict.items():
                         context += f" {key}: {value}, "
 
-                templateData["processData"]["rowData"]["context"]["value"] = context.strip()
+                templateData["processData"]["rowData"]["context"][
+                    "value"
+                ] = context.strip()
                 templateData["processData"]["rowData"]["query"]["value"] = query.strip()
 
                 if promptTemplate and not query.strip():
-                    templateData["processData"]["rowData"]["query"]["value"] = promptTemplate
+                    templateData["processData"]["rowData"]["query"][
+                        "value"
+                    ] = promptTemplate
 
                 # print(templateData)
                 currentBatch.append(templateData)
 
             if len(currentBatch) == 10 or index == len(dataframe) - 1:
-                    self.allBatches.append(currentBatch)
-                    currentBatch = []
+                self.allBatches.append(currentBatch)
+                currentBatch = []
 
             # Post all batches
             total_items = sum(len(batch) for batch in self.allBatches)
@@ -516,7 +559,12 @@ class LlumoClient:
             # print(f"All batches posted. Waiting up to {timeout} seconds for results...")
 
             # Listen for results
-            self.socket.listenForResults(min_wait=20, max_wait=timeout, inactivity_timeout=30,expected_results=None)
+            self.socket.listenForResults(
+                min_wait=20,
+                max_wait=timeout,
+                inactivity_timeout=30,
+                expected_results=None,
+            )
 
             # Get results for this evaluation
             eval_results = self.socket.getReceivedData()
@@ -539,17 +587,33 @@ class LlumoClient:
             except Exception as e:
                 print(f"Error disconnecting socket: {e}")
 
-        compressed_prompt , compressed_prompt_output  , cost , cost_saving  = costColumnMapping(results,self.processMapping)
+        compressed_prompt, compressed_prompt_output, cost, cost_saving = (
+            costColumnMapping(results, self.processMapping)
+        )
         dataframe["compressed_prompt"] = compressed_prompt
         dataframe["compressed_prompt_output"] = compressed_prompt_output
         dataframe["cost"] = cost
         dataframe["cost_saving"] = cost_saving
-        return dataframe
 
+        return dataframe
 
-    def run_sweep(self,templates: List[str], dataset: Dict[str, List[str]], model_aliases: List[AVAILABLEMODELS], apiKey: str, eval  = ["Response Correctness"],toEvaluate:bool =False ) -> pd.DataFrame:
+    def run_sweep(
+        self,
+        templates: List[str],
+        dataset: Dict[str, List[str]],
+        model_aliases: List[AVAILABLEMODELS],
+        apiKey: str,
+        eval=["Response Correctness"],
+        toEvaluate: bool = False,
+        createExperiment: bool = False,
+    ) -> pd.DataFrame:
+        try:
+            self.validateApiKey()
+        except Exception as e:
+            raise "Some error ocuured please check your API key"
+        workspaceID = self.workspaceID
+        email = self.email
         executor = ModelExecutor(apiKey)
-
         keys = list(dataset.keys())
         value_combinations = list(itertools.product(*dataset.values()))
         combinations = [dict(zip(keys, values)) for values in value_combinations]
@@ -568,65 +632,123 @@ class LlumoClient:
                         "template": template,
                         "prompt": prompt,
                         **combo,
-                        "model": model.value
+                        "model": model.value,
                     }
 
-                    
                     try:
                         provider = getProviderFromModel(model)
-                        response = executor.execute(provider, model.value, prompt, apiKey)
+                        response = executor.execute(
+                            provider, model.value, prompt, apiKey
+                        )
                         row["output"] = response
                     except Exception as e:
                         row["output"] = f"Error: {str(e)}"
-                    
+
                     results.append(row)
-        df=pd.DataFrame(results)
+        df = pd.DataFrame(results)
         if toEvaluate:
-        
-            res = self.evaluate(df,eval  =eval ,prompt_template=str(templates[0]))
-            return res
-        
-        return df
-
-    def evaluateAgents(self, dataframe, model, agents, model_api_key=None,
-                       prompt_template="Give answer for the given query: {{query}}"):
+
+            res = self.evaluate(df, eval=eval, prompt_template=str(templates[0]))
+
+            if createExperiment:
+                pd.set_option("future.no_silent_downcasting", True)
+                res = res.fillna("Some error occured")
+                if createPlayground(email, workspaceID, res):
+                    print(
+                        "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                    )
+            else:
+                return res
+
+        else:
+            if createExperiment:
+                pd.set_option("future.no_silent_downcasting", True)
+                df = df.fillna("Some error occured")
+                if createPlayground(email, workspaceID, df):
+                    print(
+                        "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                    )
+            else:
+                return df
+
+    def evaluateAgents(
+        self,
+        dataframe,
+        model,
+        agents,
+        model_api_key=None,
+        prompt_template="Give answer for the given query: {{query}}",
+        createExperiment: bool = False,
+    ):
         if model.lower() not in ["openai", "google"]:
             raise ValueError("Model must be 'openai' or 'google'")
 
         # Run unified agent execution
-        toolResponseDf = LlumoAgentExecutor.run(dataframe, agents, model=model, model_api_key=model_api_key)
-        evals = ["Tool Reliability", "Stepwise Progression", "Tool Selection Accuracy", "Final Task Alignment"]
+        toolResponseDf = LlumoAgentExecutor.run(
+            dataframe, agents, model=model, model_api_key=model_api_key
+        )
+        evals = [
+            "Tool Reliability",
+            "Stepwise Progression",
+            "Tool Selection Accuracy",
+            "Final Task Alignment",
+        ]
 
         for eval in evals:
             # Perform evaluation
             toolResponseDf = self.evaluate(
                 toolResponseDf,
-                eval = eval,
-                prompt_template=prompt_template
+                eval=eval,
+                prompt_template=prompt_template,
+                createExperiment=False,
             )
-        return toolResponseDf
+        if createExperiment:
+            pd.set_option("future.no_silent_downcasting", True)
+            df = toolResponseDf.fillna("Some error occured")
+            if createPlayground(self.email, self.workspaceID, df):
+                print(
+                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                )
+        else:
+            return toolResponseDf
 
-    def evaluateAgentResponses(self, dataframe, prompt_template="Give answer for the given query: {{query}}"):
+    def evaluateAgentResponses(
+        self,
+        dataframe,
+        prompt_template="Give answer for the given query: {{query}}",
+        createExperiment: bool = False,
+    ):
         try:
             if "query" and "messageHistory" and "tools" not in dataframe.columns:
-                raise ValueError("DataFrame must contain 'query', 'messageHistory', and 'tools' columns")
-            evals = ["Tool Reliability", "Stepwise Progression", "Tool Selection Accuracy", "Final Task Alignment"]
+                raise ValueError(
+                    "DataFrame must contain 'query', 'messageHistory', and 'tools' columns"
+                )
+            evals = [
+                "Tool Reliability",
+                "Stepwise Progression",
+                "Tool Selection Accuracy",
+                "Final Task Alignment",
+            ]
             toolResponseDf = dataframe.copy()
             for eval in evals:
                 # Perform evaluation
                 toolResponseDf = self.evaluate(
-                    toolResponseDf,
-                    eval = eval,
-                    prompt_template=prompt_template
+                    toolResponseDf, eval=eval, prompt_template=prompt_template
                 )
             return toolResponseDf
-            
+
         except Exception as e:
             raise e
-    
-    def runDataStream(self, dataframe, streamName:str,queryColName:str="query"):
+
+    def runDataStream(
+        self,
+        dataframe,
+        streamName: str,
+        queryColName: str = "query",
+        createExperiment: bool = False,
+    ):
         results = {}
-        
+
         try:
             socketID = self.socket.connect(timeout=150)
             # Ensure full connection before proceeding
@@ -636,7 +758,9 @@ class LlumoClient:
                 time.sleep(0.1)
                 waited_secs += 0.1
                 if waited_secs >= max_wait_secs:
-                    raise RuntimeError("Timeout waiting for server 'connection-established' event.")
+                    raise RuntimeError(
+                        "Timeout waiting for server 'connection-established' event."
+                    )
             # print(f"Connected with socket ID: {socketID}")
             rowIdMapping = {}
             try:
@@ -650,25 +774,32 @@ class LlumoClient:
                     print(f"Response content: {e.response.text[:500]}...")
                 raise
             # check for available hits and trial limit
-            userHits = checkUserHits(self.workspaceID, self.hasSubscribed, self.trialEndDate, self.subscriptionEndDate,
-                                     self.hitsAvailable, len(dataframe))
+            userHits = checkUserHits(
+                self.workspaceID,
+                self.hasSubscribed,
+                self.trialEndDate,
+                self.subscriptionEndDate,
+                self.hitsAvailable,
+                len(dataframe),
+            )
 
-           # do not proceed if subscription or trial limit has exhausted
+            # do not proceed if subscription or trial limit has exhausted
             if not userHits["success"]:
                 raise LlumoAIError.InsufficientCredits(userHits["message"])
 
-            
-
             print("====🚀Sit back while we fetch data from the stream 🚀====")
             workspaceID = self.workspaceID
-            streamId=getStreamId(workspaceID,self.apiKey,streamName)
+            email = self.email
+            streamId = getStreamId(workspaceID, self.apiKey, streamName)
             # Prepare all batches before sending
             # print("Preparing batches...")
             self.allBatches = []
             currentBatch = []
 
             for index, row in dataframe.iterrows():
-                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
+                    "-", ""
+                )
                 rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
                 columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
 
@@ -678,28 +809,24 @@ class LlumoClient:
                     "processID": getProcessID(),
                     "socketID": socketID,
                     "processData": {
-                        "executionDependency": {
-                            "query": row[queryColName]
-                        },
-                        "dataStreamID": streamId
+                        "executionDependency": {"query": row[queryColName]},
+                        "dataStreamID": streamId,
                     },
                     "workspaceID": workspaceID,
-                    "email": "",
+                    "email": email,
                     "type": "DATA_STREAM",
                     "playgroundID": activePlayground,
                     "processType": "DATA_STREAM",
                     "rowID": rowID,
                     "columnID": columnID,
-                    "source": "SDK"
-   
+                    "source": "SDK",
                 }
 
-
                 currentBatch.append(templateData)
 
             if len(currentBatch) == 10 or index == len(dataframe) - 1:
-                    self.allBatches.append(currentBatch)
-                    currentBatch = []
+                self.allBatches.append(currentBatch)
+                currentBatch = []
 
             # Post all batches
             total_items = sum(len(batch) for batch in self.allBatches)
@@ -724,7 +851,12 @@ class LlumoClient:
             # print(f"All batches posted. Waiting up to {timeout} seconds for results...")
 
             # Listen for results
-            self.socket.listenForResults(min_wait=20, max_wait=timeout, inactivity_timeout=30,expected_results=None)
+            self.socket.listenForResults(
+                min_wait=20,
+                max_wait=timeout,
+                inactivity_timeout=30,
+                expected_results=None,
+            )
 
             # Get results for this evaluation
             eval_results = self.socket.getReceivedData()
@@ -734,7 +866,6 @@ class LlumoClient:
             results["Data Stream"] = self.finalResp(eval_results)
             print(f"=======You are all set! continue your expectations 🚀======\n")
 
-            
             # print("All evaluations completed successfully")
 
         except Exception as e:
@@ -752,31 +883,44 @@ class LlumoClient:
             dataframe[streamName] = None
             for item in records:
                 for compound_key, value in item.items():
-                # for compound_key, value in item['data'].items():
+                    # for compound_key, value in item['data'].items():
 
-                    rowID = compound_key.split('-')[0]
+                    rowID = compound_key.split("-")[0]
                     # looking for the index of each rowID , in the original dataframe
                     if rowID in rowIdMapping:
                         index = rowIdMapping[rowID]
                         # dataframe.at[index, evalName] = value
                         dataframe.at[index, streamName] = value["value"]
-                        
-
 
                     else:
                         pass
                         # print(f"⚠️ Warning: Could not find rowID {rowID} in mapping")
 
-        return dataframe
-    
-    
-    
-    def getId(self,workspaceID,streamName):
-        streamId=getStreamId(workspaceID,self.apiKey,streamName)
-        return streamId
-    
-    
-        
+        if createExperiment:
+            pd.set_option("future.no_silent_downcasting", True)
+            df = dataframe.fillna("Some error occured").astype(object)
+
+            if createPlayground(email, workspaceID, df):
+                print(
+                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                )
+        else:
+            self.latestDataframe = dataframe
+            return dataframe
+
+    def createExperiment(self, dataframe):
+        try:
+            self.validateApiKey()
+
+            flag = createPlayground(self.email, self.workspaceID, dataframe)
+            if flag:
+                print(
+                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                )
+        except Exception as e:
+            raise "Some error ocuured please check your API key"
+
+
 class SafeDict(dict):
     def __missing__(self, key):
         return ""

llumo/helpingFuntions.py

@@ -1,18 +1,27 @@
 import time
 import uuid
 import numpy as np
-from  datetime import datetime
+from datetime import datetime
 from dateutil import parser
 import requests
 import json
 import base64
 import os
 from dotenv import load_dotenv
-load_dotenv()
 
-subscriptionUrl = os.getenv("SUBSCRIPTION_URL")
-getStreamdataUrl = os.getenv("DATA_STREAM_URL")
 
+load_dotenv()
+
+subscriptionUrl = "https://app.llumo.ai/api/workspace/record-extra-usage"
+getStreamdataUrl = "https://app.llumo.ai/api/data-stream/all"
+createPlayUrl = "https://app.llumo.ai/api/New-Eval-API/create-new-eval-playground"
+deletePlayUrl = "https://app.llumo.ai/api/New-Eval-API/new-upload-flow/delete-columnlist-in-playground"
+uploadColList = (
+    "https://app.llumo.ai/api/New-Eval-API/new-upload-flow/uploadColumnListInPlayground"
+)
+uploadRowList = (
+    "https://app.llumo.ai/api/New-Eval-API/new-upload-flow/uploadRowsInDBPlayground"
+)
 
 
 def getProcessID():
@@ -24,6 +33,7 @@ def getInputPopulatedPrompt(promptTemplate, tempObj):
         promptTemplate = promptTemplate.replace(f"{{{{{key}}}}}", value)
     return promptTemplate
 
+
 def costColumnMapping(costResults, allProcess):
     # this dict will store cost column data for each row
     cost_cols = {}
@@ -63,7 +73,14 @@ def costColumnMapping(costResults, allProcess):
     return compressed_prompt, compressed_prompt_output, cost, cost_saving
 
 
-def checkUserHits(workspaceID, hasSubscribed, trialEndDate, subscriptionEndDate, remainingHits, datasetLength):
+def checkUserHits(
+    workspaceID,
+    hasSubscribed,
+    trialEndDate,
+    subscriptionEndDate,
+    remainingHits,
+    datasetLength,
+):
     # Get the current date (only the date part)
     current_date = datetime.now().date()
 
@@ -99,7 +116,9 @@ def checkUserHits(workspaceID, hasSubscribed, trialEndDate, subscriptionEndDate,
                 "Content-Type": "application/json",
             }
             reqBody = {"unitsToSet": 1}
-            responseBody = requests.post(url=subscriptionUrl, json=reqBody, headers=headers)
+            responseBody = requests.post(
+                url=subscriptionUrl, json=reqBody, headers=headers
+            )
             response = json.loads(responseBody.text)
 
             proceed = response.get("execution", "")
@@ -110,6 +129,7 @@ def checkUserHits(workspaceID, hasSubscribed, trialEndDate, subscriptionEndDate,
 
     return {"success": True, "message": "Access granted."}
 
+
 def getStreamId(workspaceID: str, token, dataStreamName):
     headers = {
         "Authorization": f"Bearer {token}",
@@ -123,15 +143,164 @@ def getStreamId(workspaceID: str, token, dataStreamName):
         data = responseJson.get("data", [])
 
         # Find stream by name
-        matchedStream = next((stream for stream in data if stream.get("name") == dataStreamName), None)
+        matchedStream = next(
+            (stream for stream in data if stream.get("name") == dataStreamName), None
+        )
 
         if matchedStream:
-            
+
             return matchedStream.get("dataStreamID")
-            
+
         else:
             print(f"No stream found with name: {dataStreamName}")
             return None
     else:
         print("Error:", response.status_code, response.text)
-        return None
+        return None
+
+
+def createEvalPlayground(email: str, workspaceID: str):
+    url = createPlayUrl
+    headers = {
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "email": email,
+        "workspaceID": workspaceID,
+    }
+
+    response = requests.post(url, json=payload, headers=headers)
+
+    if response.status_code == 200:
+        try:
+            responseJson = response.json()
+            # print(responseJson)
+            return responseJson.get("data", {}).get("playgroundID", None)
+
+        except Exception as e:
+            print("Failed to parse JSON:", e)
+            return None
+    else:
+        print("Error:", response.status_code, response.text)
+        return None
+
+
+def deleteColumnListInPlayground(workspaceID: str, playgroundID: str):
+    url = deletePlayUrl
+    headers = {
+        "Content-Type": "application/json",
+    }
+    payload = {
+        "workspaceID": workspaceID,
+        "playgroundID": playgroundID,
+    }
+
+    response = requests.post(url, json=payload, headers=headers)
+
+    if response.status_code == 200:
+        try:
+
+            return response.json()
+        except Exception as e:
+            print("⚠️ Failed to parse JSON:", e)
+            return None
+    else:
+        print("❌ Error:", response.status_code, response.text)
+        return None
+
+
+def createColumn(workspaceID, dataframe, playgroundID):
+
+    if len(dataframe) > 100:
+        dataframe = dataframe.head(100)
+        print("⚠️ Dataframe truncated to 100 rows for upload.")
+
+    playgroundID = playgroundID
+
+    coltemplate = {
+        "workspaceID": workspaceID,
+        "playgroundID": playgroundID,
+        "columnListToUpload": [],
+    }
+
+    for indx, col in enumerate(dataframe.columns):
+        template = {
+            "label": col,
+            "type": "VARIABLE",
+            "variableType": "STRING",
+            "order": indx,
+            "columnID": col,
+        }
+        coltemplate["columnListToUpload"].append(template)
+
+    rowTemplate = {
+        "workspaceID": workspaceID,
+        "playgroundID": playgroundID,
+        "dataToUploadList": [],
+        "columnList": coltemplate["columnListToUpload"],
+    }
+
+    for indx, row in dataframe.iterrows():
+        row_dict = row.to_dict()
+        row_dict["pIndex"] = indx
+        rowTemplate["dataToUploadList"].append(row_dict)
+
+    return coltemplate, rowTemplate
+
+
+def uploadColumnListInPlayground(payload):
+    url = uploadColList
+    headers = {
+        "Content-Type": "application/json",
+    }
+    payload = payload
+
+    response = requests.post(url, json=payload, headers=headers)
+
+    if response.status_code == 200:
+        try:
+
+            return response.json()
+        except Exception as e:
+            print("⚠️ Failed to parse JSON:", e)
+            return None
+    else:
+        print("❌ Error:", response.status_code, response.text)
+        return None
+
+
+def uploadRowsInDBPlayground(payload):
+    url = uploadRowList
+    headers = {
+        "Content-Type": "application/json",
+    }
+
+    payload = payload
+
+    response = requests.post(url, json=payload, headers=headers)
+
+    if response.status_code == 200:
+        try:
+
+            return response.json()
+        except Exception as e:
+            print("⚠️ Failed to parse JSON:", e)
+            return None
+    else:
+        print("❌ Error:", response.status_code, response.text)
+        return None
+
+
+def createPlayground(email, workspaceID, df):
+    playgroundId = str(createEvalPlayground(email=email, workspaceID=workspaceID))
+    payload1, payload2 = createColumn(
+        workspaceID=workspaceID, dataframe=df, playgroundID=playgroundId
+    )
+    deleteExistingRows = deleteColumnListInPlayground(
+        workspaceID=workspaceID, playgroundID=playgroundId
+    )
+    colListUpload = uploadColumnListInPlayground(payload=payload1)
+    rowListUpload = uploadRowsInDBPlayground(payload=payload2)
+
+    if rowListUpload:
+        return True

{llumo-0.2.0.dist-info → llumo-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: llumo
-Version: 0.2.0
+Version: 0.2.2
 Summary: Python SDK for interacting with the Llumo ai API.
 Home-page: https://www.llumo.ai/
 Author: Llumo

{llumo-0.2.0.dist-info → llumo-0.2.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 llumo/__init__.py,sha256=O04b4yW1BnOvcHzxWFddAKhtdBEhBNhLdb6xgnpHH_Q,205
-llumo/client.py,sha256=F4zabvAjLnu0N61qSw5DqerNlV5ybC2DbxaI55olldg,31916
+llumo/client.py,sha256=DTl-kCgEYmPEshG6Tnkmg8nmfMqWyA1u3vyiep-MftU,35795
 llumo/exceptions.py,sha256=iCj7HhtO_ckC2EaVBdXbAudNpuMDsYmmMEV5lwynZ-E,1854
 llumo/execution.py,sha256=x88wQV8eL99wNN5YtjFaAMCIfN1PdfQVlAZQb4vzgQ0,1413
 llumo/functionCalling.py,sha256=QtuTtyoz5rnfNUrNT1kzegNPOrMFjrlgxZfwTqRMdiA,7190
-llumo/helpingFuntions.py,sha256=9w1J4wMnJV1v_5yFMyxIHcvc16sEq5MZzOFBPagij5Q,4467
+llumo/helpingFuntions.py,sha256=mDGOjeqJI1NOdoaT5FK3tlhWwhpZnk1nCnZOan0AFk0,8886
 llumo/models.py,sha256=YH-qAMnShmUpmKE2LQAzQdpRsaXkFSlOqMxHwU4zBUI,1560
 llumo/sockets.py,sha256=Qxxqtx3Hg07HLhA4QfcipK1ChiOYhHZBu02iA6MfYlQ,5579
-llumo-0.2.0.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
-llumo-0.2.0.dist-info/METADATA,sha256=z8Ec84QAe1khloO38UkicxqVGukFid_3aeptYpHra0I,426
-llumo-0.2.0.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-llumo-0.2.0.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
-llumo-0.2.0.dist-info/RECORD,,
+llumo-0.2.2.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
+llumo-0.2.2.dist-info/METADATA,sha256=PbBK3grNMsj7LANu5bl_FBmBiJlQkzb0sACk7d-j7_c,426
+llumo-0.2.2.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+llumo-0.2.2.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
+llumo-0.2.2.dist-info/RECORD,,