llumo 0.2.11__py3-none-any.whl → 0.2.13__py3-none-any.whl

llumo/client.py

@@ -30,6 +30,7 @@ class LlumoClient:
         self.apiKey = api_key
         self.socket = LlumoSocketClient(socketUrl)
         self.processMapping = {}
+        self.definationMapping = {}
 
     def validateApiKey(self, evalName=" "):
         headers = {
@@ -87,6 +88,8 @@ class LlumoClient:
             self.trialEndDate = data["data"]["data"].get("trialEndDate", None)
             self.subscriptionEndDate = data["data"]["data"].get("subscriptionEndDate", None)
             self.email = data["data"]["data"].get("email", None)
+            
+            self.definationMapping[evalName] = self.evalDefinition
 
         except Exception as e:
             # print(f"Error extracting data from response: {str(e)}")
@@ -153,6 +156,7 @@ class LlumoClient:
 
         return uniqueResults
 
+    # this function allows the users to run exactl one eval at a time
     def evaluate(
         self,
         dataframe,
@@ -314,6 +318,7 @@ class LlumoClient:
 
             for cnt, batch in enumerate(self.allBatches):
                 try:
+                    
                     self.postBatch(batch=batch, workspaceID=workspaceID)
                     # print("Betch Posted with item len: ", len(batch))
                 except Exception as e:
@@ -362,38 +367,53 @@ class LlumoClient:
             pd.set_option("future.no_silent_downcasting", True)
             df = dataframe.fillna("Some error occured").astype(object)
 
-            if createPlayground(email, workspaceID, df):
+            if createPlayground(email, workspaceID, df,promptText=prompt_template,definationMapping=self.definationMapping,outputColName=outputColName):
                 print(
-                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
+                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results.Please rerun the experiment to see the results on playground."
                 )
         else:
             return dataframe
 
+    # this function allows the users to run multiple evals at once
+    def evaluateMultiple(
+            self,
+            dataframe,
+            eval=["Response Completeness"],
+            prompt_template="",
+            outputColName="output",
+            createExperiment: bool = False,
+    ):
+        resultdf  = dataframe.copy()
+        for evalName in eval:
+            resultdf = self.evaluate(dataframe = resultdf,eval=evalName,prompt_template=prompt_template,outputColName=outputColName,createExperiment = False)
+
+        if createExperiment:
+            pd.set_option("future.no_silent_downcasting", True)
+            df = resultdf.fillna("Some error occured").astype(object)
+
+            if createPlayground(self.email, self.workspaceID, df,definationMapping=self.definationMapping,outputColName=outputColName,promptText=prompt_template):
+                print(
+                    "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results.Please rerun the experiment to see the results on playground."
+                )
+        else:
+            return resultdf
+
+
     def evaluateCompressor(self, dataframe, prompt_template):
         results = []
 
         try:
-            # Connect to socket first
-            # print("Connecting to socket server...")
             socketID = self.socket.connect(timeout=150)
-
-            # Ensure full connection before proceeding
             max_wait_secs = 20
             waited_secs = 0
             while not self.socket._connection_established.is_set():
                 time.sleep(0.1)
                 waited_secs += 0.1
                 if waited_secs >= max_wait_secs:
-                    raise RuntimeError(
-                        "Timeout waiting for server 'connection-established' event."
-                    )
-
-            # print(f"Connected with socket ID: {socketID}")
+                    raise RuntimeError("Timeout waiting for server 'connection-established' event.")
 
             try:
-                # print(f"Validating API key...")
                 self.validateApiKey()
-                # print(f"API key validation successful. Hits available: {self.hitsAvailable}")
             except Exception as e:
                 print(f"Error during API key validation: {str(e)}")
                 if hasattr(e, "response") and getattr(e, "response", None) is not None:
@@ -401,61 +421,42 @@ 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
             if not userHits["success"]:
                 raise LlumoAIError.InsufficientCredits(userHits["message"])
 
-            # if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
-            #     raise LlumoAIError.InsufficientCredits()
-
             model = "GPT_4"
             provider = "OPENAI"
             evalType = "LLUMO"
             workspaceID = self.workspaceID
             email = self.email
-            # Prepare all batches before sending
-            # print("Preparing batches...")
             self.allBatches = []
             currentBatch = []
-
+            rowIdMapping = {}
             for index, row in dataframe.iterrows():
                 promptTemplate = prompt_template
-
-                # extracting the placeholders from the prompt template
                 keys = re.findall(r"{{(.*?)}}", promptTemplate)
                 inputDict = {key: row[key] for key in keys if key in row}
 
                 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("-", "")
+
+                rowDataDict = {}
+                for col in dataframe.columns:
+                    val = row[col]
+                    rowDataDict[col] = {"type": "VARIABLE", "value": str(val)}
 
-                # Use the server-provided socket ID here
                 templateData = {
                     "processID": getProcessID(),
                     "socketID": socketID,
@@ -469,13 +470,10 @@ 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": {
-                            "query": {"type": "VARIABLE", "value": ""},
-                            "context": {"type": "VARIABLE", "value": ""},
-                        },
+                        "rowData": rowDataDict,
                         "dependency": list(inputDict.keys()),
                         "dependencyMapping": {ky: ky for ky in list(inputDict.keys())},
                         "provider": provider,
@@ -485,128 +483,89 @@ 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": email,
-                    "playgroundID": activePlayground,
+                    "playgroundID": activePlayground
                 }
 
-                # Build query/context from input
-                query = ""
-                context = ""
-
-                for key, value in inputDict.items():
-                    if isinstance(value, str):
-                        length = len(value.split()) * 1.5
-                        if length > 50:
-                            context += f" {key}: {value}, "
-                        else:
-                            if promptTemplate:
-                                populatedPrompt = getInputPopulatedPrompt(
-                                    promptTemplate, {key: value}
-                                )
-                                query += f"{populatedPrompt} "
-                            else:
-                                query += f" {key}: {value}, "
-
-                if not context.strip():
-                    for key, value in inputDict.items():
-                        context += f" {key}: {value}, "
-
-                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
-
+                rowIdMapping[rowID] = index
+                # print("__________________________TEMPLATE__________________________________")
                 # print(templateData)
+
                 currentBatch.append(templateData)
 
-            if len(currentBatch) == 10 or index == len(dataframe) - 1:
-                self.allBatches.append(currentBatch)
-                currentBatch = []
+                if len(currentBatch) == 10 or index == len(dataframe) - 1:
+                    self.allBatches.append(currentBatch)
+                    currentBatch = []
 
-            # Post all batches
             total_items = sum(len(batch) for batch in self.allBatches)
-            # print(f"Posting {len(self.allBatches)} batches ({total_items} items total)")
 
             for cnt, batch in enumerate(self.allBatches):
-                # print(f"Posting batch {cnt + 1}/{len(self.allBatches)} for eval '{eval}'")
                 try:
                     self.postBatch(batch=batch, workspaceID=workspaceID)
-                    # print(f"Batch {cnt + 1} posted successfully")
                 except Exception as e:
                     print(f"Error posting batch {cnt + 1}: {str(e)}")
                     continue
-
-                # Small delay between batches to prevent overwhelming the server
                 time.sleep(1)
 
-            # updating the dict for row column mapping
             self.AllProcessMapping()
-            # Calculate a reasonable timeout based on the data size
             timeout = max(60, min(600, total_items * 10))
-            # 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,
-            )
-
-            # Get results for this evaluation
-            eval_results = self.socket.getReceivedData()
-            # print(f"Received {len(eval_results)} results for evaluation '{eval}'")
+            self.socket.listenForResults(min_wait=20, max_wait=timeout, inactivity_timeout=30, expected_results=None)
 
-            # Add these results to our overall results
-            results = self.finalResp(eval_results)
-            print(f"======= Completed evaluation: {eval} =======\n")
-
-            # print("All evaluations completed successfully")
+            results = self.socket.getReceivedData()
+            # results = self.finalResp(eval_results)
+            # print(f"======= Completed evaluation: {eval} =======\n")
 
         except Exception as e:
             print(f"Error during evaluation: {e}")
             raise
         finally:
-            # Always disconnect the socket when done
             try:
                 self.socket.disconnect()
-                # print("Socket disconnected")
             except Exception as e:
                 print(f"Error disconnecting socket: {e}")
 
-        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
+        dataframe["Compressed Input"] = None
+        for records in results:
+            for compound_key, value in records.items():
+                # for compound_key, value in item['data'].items():
+                rowID = compound_key.split('-')[0]
+                # looking for the index of each rowID , in the original dataframe
+                if rowID in rowIdMapping:
+                    index = rowIdMapping[rowID]
 
-        return dataframe
+                    dataframe.at[index, "Compressed Input"] = value["value"]
+
+                else:
+                    pass
+                    # print(f"⚠️ Warning: Could not find rowID {rowID} in mapping")
 
+        # 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
     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:
+    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"
+            raise Exception("Some error occurred, please check your API key")
+
         workspaceID = self.workspaceID
         email = self.email
         executor = ModelExecutor(apiKey)
@@ -616,57 +575,81 @@ class LlumoClient:
 
         results = []
 
-        # Iterate through combinations
         for combo in combinations:
             for template in templates:
                 prompt = template
                 for k, v in combo.items():
                     prompt = prompt.replace(f"{{{{{k}}}}}", v)
-                # Add a row for each model
-                for model in model_aliases:
-                    row = {
-                        "template": template,
-                        "prompt": prompt,
-                        **combo,
-                        "model": model.value,
-                    }
 
+                row = {
+                    "prompt": prompt,
+                    **combo,
+                }
+
+                for i, model in enumerate(model_aliases, 1):
                     try:
                         provider = getProviderFromModel(model)
-                        response = executor.execute(
-                            provider, model.value, prompt, apiKey
-                        )
-                        row["output"] = response
+                        response = executor.execute(provider, model.value, prompt, apiKey)
+                        outputKey = f"output_{i}"
+                        row[outputKey] = response
                     except Exception as e:
-                        row["output"] = f"Error: {str(e)}"
+                        row[f"output_{i}"] = str(e)
 
-                    results.append(row)
+                results.append(row)
+
+        
+        
         df = pd.DataFrame(results)
-        if toEvaluate:
 
-            res = self.evaluate(df, eval=eval, prompt_template=str(templates[0]))
+        
+        if toEvaluate==True:
+            dfWithEvals = df.copy()
+            for i, model in enumerate(model_aliases,1):
+                outputColName = f"output_{i}"
+                try:
+                    res = self.evaluateMultiple(
+                        df,
+                        eval=eval,
+                        prompt_template=str(templates[0]),
+                        outputColName=outputColName,
+                    )
+
+                    # Rename all new columns with _i+1 (e.g., _1, _2)
+                    for evalMetric in eval:
+                        scoreCol = f"{evalMetric}"
+                        reasonCol = f"{evalMetric} Reason"
+                        if scoreCol in res.columns:
+                            res = res.rename(columns={scoreCol: f"{scoreCol}_{i}"})
+                        if reasonCol in res.columns:
+                            res = res.rename(columns={reasonCol: f"{reasonCol}_{i}"})
+
+                    # Drop duplicated columns from df (like prompt, variables, etc.)
+                    newCols = [col for col in res.columns if col not in dfWithEvals.columns]
+                    dfWithEvals = pd.concat([dfWithEvals, res[newCols]], axis=1)
+
+                except Exception as e:
+                    print(f"Evaluation failed for model {model.value}: {str(e)}")
 
             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."
-                    )
+                dfWithEvals = dfWithEvals.fillna("Some error occurred")
+                if createPlayground(email, workspaceID, dfWithEvals, promptText=templates[0]):
+                    
+                    print("Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results.")
             else:
-                return res
-
+                return dfWithEvals
         else:
-            if createExperiment:
+            if createExperiment==True:
                 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:
+                df = df.fillna("Some error occurred")
+
+                if createPlayground(email, workspaceID, df, promptText=templates[0]):
+                    print("Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results.")
+            else :
                 return df
 
+
+    # this function generates an output using llm and tools and evaluate that output
     def evaluateAgents(
         self,
         dataframe,
@@ -683,6 +666,8 @@ class LlumoClient:
         toolResponseDf = LlumoAgentExecutor.run(
             dataframe, agents, model=model, model_api_key=model_api_key
         )
+        
+        
         evals = [
             "Tool Reliability",
             "Stepwise Progression",
@@ -708,34 +693,41 @@ class LlumoClient:
         else:
             return toolResponseDf
 
+    # this function evaluate that tools output given by the user
     def evaluateAgentResponses(
         self,
         dataframe,
-        prompt_template="Give answer for the given query: {{query}}",
+        evals=["Final Task Alignment"],
+        outputColName="output",
         createExperiment: bool = False,
     ):
         try:
             if "query" and "messageHistory" and "tools" not in dataframe.columns:
                 raise ValueError(
-                    "DataFrame must contain 'query', 'messageHistory', and 'tools' columns"
+                    "DataFrame must contain 'query', 'messageHistory','output' ,and 'tools' columns. Make sure the columns names are same as mentioned here."
                 )
-            evals = [
-                "Tool Reliability",
-                "Stepwise Progression",
-                "Tool Selection Accuracy",
-                "Final Task Alignment",
-            ]
+            prompt_template="Give answer for the given query: {{query}}"
+            
+            # 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,outputColName=outputColName
                 )
+                
+           
             return toolResponseDf
 
         except Exception as e:
             raise e
 
+        
     def runDataStream(
         self,
         dataframe,
@@ -896,7 +888,7 @@ class LlumoClient:
             pd.set_option("future.no_silent_downcasting", True)
             df = dataframe.fillna("Some error occured").astype(object)
 
-            if createPlayground(email, workspaceID, df):
+            if createPlayground(email, workspaceID, df,queryColName=queryColName, dataStreamName=streamId):
                 print(
                     "Your data has been saved in the Llumo Experiment. Visit https://app.llumo.ai/evallm to see the results."
                 )

llumo/helpingFuntions.py

@@ -7,6 +7,7 @@ import requests
 import json
 import base64
 import os
+import re
 
 subscriptionUrl = "https://app.llumo.ai/api/workspace/record-extra-usage"
 getStreamdataUrl = "https://app.llumo.ai/api/data-stream/all"
@@ -18,6 +19,8 @@ uploadColList = (
 uploadRowList = (
     "https://app.llumo.ai/api/New-Eval-API/new-upload-flow/uploadRowsInDBPlayground"
 )
+createInsightUrl = "https://app.llumo.ai/api/New-Eval-API/insights-api/generate-playground-insights"
+getPlaygroundInsightsUrl="https://app.llumo.ai/api/New-Eval-API/insights-api/get-all-playground-insights"
 
 
 def getProcessID():
@@ -210,30 +213,151 @@ def deleteColumnListInPlayground(workspaceID: str, playgroundID: str):
         return None
 
 
-def createColumn(workspaceID, dataframe, playgroundID):
-
+def createColumn(workspaceID, dataframe, playgroundID, promptText=None,queryColName=None,outputColName= "output",dataStreamName=None,definationMapping=None):
     if len(dataframe) > 100:
         dataframe = dataframe.head(100)
         print("⚠️ Dataframe truncated to 100 rows for upload.")
 
-    playgroundID = playgroundID
-
     coltemplate = {
         "workspaceID": workspaceID,
         "playgroundID": playgroundID,
         "columnListToUpload": [],
     }
+    allEvals = ['Response Completeness', 'Response Bias', 'Response Harmfulness', 'Input Toxicity', 'Input Harmfulness', 'Context Utilization', 'Relevance Retention', 'Semantic Cohesion', 'Final Task Alignment', 'Tool Reliability', 'Response Correctness', 'Response Toxicity', 'Input Bias', 'Input Relevancy', 'Redundancy Reduction', 'Response Sentiment', 'Tool Selection Accuracy', 'Stepwise Progression', 'Hallucination', 'Faithfulness', 'Answer Relevancy', 'Context Precision', 'Answer Similarity', 'Harmfulness', 'Maliciousness', 'Coherence', 'Answer Correctness', 'Context Recall', 'Context Entity Recall', 'Conciseness', 'customEvalColumn', 'Groundedness', 'Memory Utilization', 'Input Relevancy (Multi-turn)']
+
+
+
+    # Create a mapping of column names to unique column IDs
+    columnIDMapping = {}
 
+    # Iterate over each column in the dataframe
     for indx, col in enumerate(dataframe.columns):
-        template = {
-            "label": col,
-            "type": "VARIABLE",
-            "variableType": "STRING",
-            "order": indx,
-            "columnID": col,
-        }
+        # Generate a unique column ID using uuid
+        columnID = str(uuid.uuid4().hex[:8]) 
+
+        columnIDMapping[col] = columnID
+
+        
+        if col.startswith('output'):
+            # For output columns, create the prompt template with promptText
+            if promptText:
+                # Extract variables from promptText and set them as dependencies
+                dependencies = []
+
+                # Find variables inside {{variable}}
+                variables = re.findall(r'{{(.*?)}}', promptText)
+
+                # Loop through each variable and check if it exists as a column name
+                for var in variables:
+                    varName = var.strip() 
+                    if varName in columnIDMapping:  # Check if the variable is a column name
+                        dependencies.append(columnIDMapping[varName])  # Add its columnID
+
+                # Now update the template for the output column
+                
+                template={
+                    "provider": "OPENAI",
+                    "model": "GPT_4o",
+                    "promptText": promptText,
+                    "modelOptions": {
+                        "temperature": 0,
+                        "frequencyPenalty": 0,
+                        "presencePenalty": 0,
+                        "maxToken": 8192
+                    },
+                    "toolConfig": "none",
+                    "concurrency": "",
+                    "outputType": "STRING",
+                    "isPromptSelected": True,
+                    "isSmartPromptSelected": False,
+                    "dependency": dependencies,  # Use the dependencies extracted from promptText
+                    "columnID": columnID,  # Use the generated column ID
+                    "label": col,
+                    "type": "PROMPT",
+                    "order": indx,
+                }
+                
+        elif col.startswith('Data '):
+            if queryColName and dataStreamName:
+                dependencies = []
+                dependencies.append(columnIDMapping[queryColName])
+                template = {
+                    "variableType": "STRING",
+                    "dependency": dependencies,
+                    "dataStreamName": dataStreamName,
+                    "query": columnIDMapping[queryColName],
+                    "columnID": columnID,  # Use the generated column ID
+                    "label": "Data stream",
+                    "type": "DATA_STREAM",
+                    "order": indx}
+
+        elif col in allEvals:
+
+            dependencies = []
+            variables = re.findall(r'{{(.*?)}}', promptText)
+
+                # Loop through each variable and check if it exists as a column name
+            for var in variables:
+                varName = var.strip() 
+                if varName in columnIDMapping:  # Check if the variable is a column name
+                    dependencies.append(columnIDMapping[varName])
+                    
+            dependencies.append(columnIDMapping[outputColName])  # Add the output column ID
+            longDef = definationMapping.get(col, {}).get(col, "")
+            shortDef ="You have run this from SDK"
+            enum =  col.upper().replace(" ","_")
+
+            template = {
+      "analytics": [
+        col.lower().replace(" ","_")
+      ],
+      "evaluationMetric": "ALL",
+      "evaluationModel": "GEMINI_PRO",
+      "selectPrompt": columnIDMapping[outputColName],
+      "scoreCondition": "GREATER_THAN",
+      "scoreValue": "50",
+      "scoreResult": "PASS",
+      "llmKpi": col,
+      "setRules": True,
+      "type": "EVAL",
+      "evalType": "LLM",
+      "similarityMetric": None,
+      "embeddingModel": None,
+      "groundTruth": None,
+      "dataStream": None,
+      "context": None,
+      "dependency": [columnIDMapping[outputColName]],
+      "hallucinationFields": {
+        "query": None,
+        "context": None,
+        "output": None
+      },
+      "definition": longDef,
+      "analyticsENUM": enum,
+      "prompt": shortDef,
+      "analyticsName": col,
+      "columnID": str(uuid.uuid4().hex[:8]),
+      "label": col,
+      "order": indx
+    }
+
+           
+
+            
+        else:
+            
+            template = {
+                "label": col,  # Label is the column name
+                "type": "VARIABLE",  # Default type for non-output columns
+                "variableType": "STRING",
+                "order": indx,
+                "columnID": columnID,  # Use the generated column ID
+            }
+
+        # Append the template to the column list
         coltemplate["columnListToUpload"].append(template)
 
+    # Prepare the row template structure
     rowTemplate = {
         "workspaceID": workspaceID,
         "playgroundID": playgroundID,
@@ -241,14 +365,22 @@ def createColumn(workspaceID, dataframe, playgroundID):
         "columnList": coltemplate["columnListToUpload"],
     }
 
+    # Populate dataToUploadList with rows from the dataframe
     for indx, row in dataframe.iterrows():
-        row_dict = row.to_dict()
+        row_dict = {}
+
+        # For each column, we need to map the column ID to the corresponding value in the row
+        for col in dataframe.columns:
+            columnID = columnIDMapping[col]  # Get the columnID from the mapping
+            row_dict[columnID] = row[col]  # Map the columnID to the value in the row
+
+        # Add the row index (if necessary)
         row_dict["pIndex"] = indx
         rowTemplate["dataToUploadList"].append(row_dict)
 
+    # Return the column template, row template, and the column ID mapping
     return coltemplate, rowTemplate
 
-
 def uploadColumnListInPlayground(payload):
     url = uploadColList
     headers = {
@@ -292,10 +424,11 @@ def uploadRowsInDBPlayground(payload):
         return None
 
 
-def createPlayground(email, workspaceID, df):
+def createPlayground(email, workspaceID, df, promptText=None,queryColName=None,dataStreamName=None,definationMapping=None,outputColName="output"):
+    
     playgroundId = str(createEvalPlayground(email=email, workspaceID=workspaceID))
     payload1, payload2 = createColumn(
-        workspaceID=workspaceID, dataframe=df, playgroundID=playgroundId
+        workspaceID=workspaceID, dataframe=df, playgroundID=playgroundId, promptText=promptText,queryColName=queryColName,dataStreamName=dataStreamName,definationMapping=definationMapping,outputColName=outputColName
     )
     deleteExistingRows = deleteColumnListInPlayground(
         workspaceID=workspaceID, playgroundID=playgroundId
@@ -305,3 +438,56 @@ def createPlayground(email, workspaceID, df):
 
     if rowListUpload:
         return True
+
+
+
+def getPlaygroundInsights(workspaceID: str, activePlayground: str):
+    headers = {
+        
+        "Content-Type": "application/json",
+    }
+
+    # Initial request to generate playground insights
+    payload = {
+        "activePlayground": activePlayground,
+        "workspaceID": workspaceID,
+    }
+
+    urlGenerate = createInsightUrl
+    
+    responseGenerate = requests.post(urlGenerate, json=payload, headers=headers)
+
+    if responseGenerate.status_code == 200:
+        responseJson = responseGenerate.json()
+        
+        insightStatus = responseJson.get("data", {}).get("insight", False)
+
+        if insightStatus:
+            # If insight is true, request to get all playground insights
+            urlGetAll = getPlaygroundInsightsUrl
+            
+            responseGetAll = requests.post(urlGetAll, json=payload, headers=headers)
+
+            if responseGetAll.status_code == 200:
+                responseAllJson = responseGetAll.json()
+                
+                data = responseAllJson.get("data", {}).get("data", [])
+                
+                # Extract insight and solution
+                insights = []
+                for item in data:
+                    insight = item.get("insight", "")
+                    solution = item.get("solution", "")
+                    insights.append({"insight": insight, "solution": solution})
+
+                return insights
+            else:
+                print(f"Error fetching all insights: {responseGetAll.status_code} - {responseGetAll.text}")
+                return None
+        else:
+            print("No insight generated.")
+            return None
+    else:
+        print(f"Error generating insight: {responseGenerate.status_code} - {responseGenerate.text}")
+        return None
+

llumo/sockets.py

@@ -128,7 +128,7 @@ class LlumoSocketClient:
                     self._listening_done.set()
                     break
 
-                time.sleep(1)
+                time.sleep(3)
 
         timeout_thread = threading.Thread(target=timeout_watcher, daemon=True)
         timeout_thread.start()

{llumo-0.2.11.dist-info → llumo-0.2.13.dist-info}/METADATA

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

llumo-0.2.13.dist-info/RECORD

@@ -0,0 +1,13 @@
+llumo/__init__.py,sha256=O04b4yW1BnOvcHzxWFddAKhtdBEhBNhLdb6xgnpHH_Q,205
+llumo/client.py,sha256=mVqxNyYMbHlL9lnkpw_H6_n98WYO38ZcLZNnQX1TjUE,35948
+llumo/exceptions.py,sha256=iCj7HhtO_ckC2EaVBdXbAudNpuMDsYmmMEV5lwynZ-E,1854
+llumo/execution.py,sha256=x88wQV8eL99wNN5YtjFaAMCIfN1PdfQVlAZQb4vzgQ0,1413
+llumo/functionCalling.py,sha256=D5jYapu1rIvdIJNUYPYMTyhQ1H-6nkwoOLMi6eekfUE,7241
+llumo/helpingFuntions.py,sha256=ah0FUQcRV3gfguvjQQ_aZzq59hpJttqAPJdjJVNYdFc,17110
+llumo/models.py,sha256=YH-qAMnShmUpmKE2LQAzQdpRsaXkFSlOqMxHwU4zBUI,1560
+llumo/sockets.py,sha256=i90l2rr08paa-ifKy2E5YMIS8r3yRBmu2CUOjhFKork,5579
+llumo-0.2.13.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
+llumo-0.2.13.dist-info/METADATA,sha256=W-ZVsTKhiPw6strlNQEqyufgOLfV9ZCjCpY6Dj3Qc94,1491
+llumo-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llumo-0.2.13.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
+llumo-0.2.13.dist-info/RECORD,,

{llumo-0.2.11.dist-info → llumo-0.2.13.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

llumo-0.2.11.dist-info/RECORD

@@ -1,13 +0,0 @@
-llumo/__init__.py,sha256=O04b4yW1BnOvcHzxWFddAKhtdBEhBNhLdb6xgnpHH_Q,205
-llumo/client.py,sha256=_TpTvzt5ox5MUCZ5O07AY6DYrtIhtezEDAE6nG7nUjs,35632
-llumo/exceptions.py,sha256=iCj7HhtO_ckC2EaVBdXbAudNpuMDsYmmMEV5lwynZ-E,1854
-llumo/execution.py,sha256=x88wQV8eL99wNN5YtjFaAMCIfN1PdfQVlAZQb4vzgQ0,1413
-llumo/functionCalling.py,sha256=D5jYapu1rIvdIJNUYPYMTyhQ1H-6nkwoOLMi6eekfUE,7241
-llumo/helpingFuntions.py,sha256=lG_d3lQgJj6pI7v1YdLqdPojrLCNwybKz29zXrGaL5k,9090
-llumo/models.py,sha256=YH-qAMnShmUpmKE2LQAzQdpRsaXkFSlOqMxHwU4zBUI,1560
-llumo/sockets.py,sha256=Qxxqtx3Hg07HLhA4QfcipK1ChiOYhHZBu02iA6MfYlQ,5579
-llumo-0.2.11.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
-llumo-0.2.11.dist-info/METADATA,sha256=ymWr0L9PnYitu0FnBAZ2NsJnlOxhcsUoUVA8Yn-DXoQ,1491
-llumo-0.2.11.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-llumo-0.2.11.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
-llumo-0.2.11.dist-info/RECORD,,