llumo 0.2.24__py3-none-any.whl → 0.2.26__py3-none-any.whl

llumo/client.py

@@ -16,11 +16,11 @@ from .exceptions import LlumoAIError
 from .helpingFuntions import *
 from .sockets import LlumoSocketClient
 from .functionCalling import LlumoAgentExecutor
-from .chains import LlumoDataFrameResults,LlumoDictResults
+from .chains import LlumoDataFrameResults, LlumoDictResults
 import threading
 from tqdm import tqdm
 
-pd.set_option('future.no_silent_downcasting', True)
+pd.set_option("future.no_silent_downcasting", True)
 
 postUrl = (
     "https://red-skull-service-392377961931.us-central1.run.app/api/process-playground"
@@ -39,10 +39,11 @@ socketUrl = "https://red-skull-service-392377961931.us-central1.run.app/"
 
 class LlumoClient:
 
-    def __init__(self, api_key):
+    def __init__(self, api_key, playground_id=None):
         self.apiKey = api_key
-        self.evalData=[]
-        self.evals=[]
+        self.playgroundID = playground_id
+        self.evalData = []
+        self.evals = []
         self.processMapping = {}
         self.definationMapping = {}
 
@@ -54,7 +55,7 @@ class LlumoClient:
         reqBody = {"analytics": [evalName]}
 
         try:
-            
+
             response = requests.post(url=validateUrl, json=reqBody, headers=headers)
 
         except requests.exceptions.RequestException as e:
@@ -99,20 +100,90 @@ class LlumoClient:
             )
             self.email = data["data"]["data"].get("email", None)
 
-            self.definationMapping[evalName] = data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "")
-            self.categories = data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("categories", {})
-            self.evaluationStrictness=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("evaluationStrictness", {})
-            self.grammarCheckOutput=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("grammarCheckOutput", {})
-            self.insightsLength=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("insightsLength", {})
-            self.insightsLevel=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("insightsLevel", {})
-            self.executionDependency=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("executionDependency", {})
-            self.sampleData=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("sampleData", {})
-            self.numJudges=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("numJudges", {})
-            self.penaltyBonusInstructions=data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("penaltyBonusInstructions", [])
-            self.probableEdgeCases= data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("probableEdgeCases", [])
-            self.fieldMapping= data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, "").get("fieldMapping", [])
-           
-            
+            self.definationMapping[evalName] = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+            )
+            self.categories = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("categories", {})
+            )
+            self.evaluationStrictness = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("evaluationStrictness", {})
+            )
+            self.grammarCheckOutput = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("grammarCheckOutput", {})
+            )
+            self.insightsLength = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("insightsLength", {})
+            )
+            self.insightsLevel = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("insightsLevel", {})
+            )
+            self.executionDependency = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("executionDependency", {})
+            )
+            self.sampleData = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("sampleData", {})
+            )
+            self.numJudges = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("numJudges", {})
+            )
+            self.penaltyBonusInstructions = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("penaltyBonusInstructions", [])
+            )
+            self.probableEdgeCases = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("probableEdgeCases", [])
+            )
+            self.fieldMapping = (
+                data.get("data", {})
+                .get("data", {})
+                .get("analyticsMapping", {})
+                .get(evalName, "")
+                .get("fieldMapping", [])
+            )
+
         except Exception as e:
             # print(f"Error extracting data from response: {str(e)}")
             raise LlumoAIError.UnexpectedError(detail=evalName)
@@ -548,7 +619,7 @@ class LlumoClient:
                     "playgroundID": activePlayground,
                 }
 
-                rowIdMapping[f'{rowID}-{columnID}-{columnID}'] = index
+                rowIdMapping[f"{rowID}-{columnID}-{columnID}"] = index
                 # print("__________________________TEMPLATE__________________________________")
                 # print(templateData)
 
@@ -628,11 +699,11 @@ class LlumoClient:
     def evaluateMultiple(
         self,
         data,
-        evals: list,  # list of eval metric names
+        evals: list,
         prompt_template="Give answer to the given query: {{query}} using the given context: {{context}}.",
         outputColName="output",
         createExperiment: bool = False,
-        getDataFrame:bool =False,
+        getDataFrame: bool = False,
         _tocheck=True,
     ):
         if isinstance(data, dict):
@@ -647,10 +718,10 @@ class LlumoClient:
         try:
             socketID = self.socket.connect(timeout=250)
         except Exception as e:
-            socketID="DummySocketID"
-            
-        self.evalData=[]
-        self.evals=evals
+            socketID = "DummySocketID"
+
+        self.evalData = []
+        self.evals = evals
         self.allBatches = []
         rowIdMapping = {}  # (rowID-columnID-columnID -> (index, evalName))
 
@@ -679,21 +750,18 @@ class LlumoClient:
         )
         listener_thread.start()
         self.validateApiKey(evalName=evals[0])
-        if createExperiment:
-            activePlayground = str(createEvalPlayground(email=self.email, workspaceID=self.workspaceID))
-            
-        else:    
-            activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
-                        "-", ""
-                    )        
+        activePlayground = self.playgroundID
         for evalName in evals:
             # print(f"\n======= Running evaluation for: {evalName} =======")
 
             # Validate API and dependencies
             self.validateApiKey(evalName=evalName)
-            customAnalytics=getCustomAnalytics(self.workspaceID)
+            customAnalytics = getCustomAnalytics(self.workspaceID)
             metricDependencies = checkDependency(
-                evalName, list(dataframe.columns), tocheck=_tocheck,customevals=customAnalytics
+                evalName,
+                list(dataframe.columns),
+                tocheck=_tocheck,
+                customevals=customAnalytics,
             )
             if not metricDependencies["status"]:
                 raise LlumoAIError.dependencyError(metricDependencies["message"])
@@ -704,15 +772,14 @@ class LlumoClient:
             evalType = "LLM"
             workspaceID = self.workspaceID
             email = self.email
-            categories=self.categories
-            evaluationStrictness=self.evaluationStrictness
-            grammarCheckOutput=self.grammarCheckOutput
-            insightLength=self.insightsLength
-            numJudges=self.numJudges
-            penaltyBonusInstructions=self.penaltyBonusInstructions
-            probableEdgeCases=self.probableEdgeCases
-            fieldMapping=self.fieldMapping
-            
+            categories = self.categories
+            evaluationStrictness = self.evaluationStrictness
+            grammarCheckOutput = self.grammarCheckOutput
+            insightLength = self.insightsLength
+            numJudges = self.numJudges
+            penaltyBonusInstructions = self.penaltyBonusInstructions
+            probableEdgeCases = self.probableEdgeCases
+            fieldMapping = self.fieldMapping
 
             userHits = checkUserHits(
                 self.workspaceID,
@@ -744,7 +811,6 @@ class LlumoClient:
                 output = row.get(outputColName, "")
                 intermediateSteps = row.get("intermediateSteps", "")
 
-                
                 rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
                 columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
 
@@ -774,7 +840,7 @@ class LlumoClient:
                             "MessageHistory": messageHistory,
                             "IntermediateSteps": intermediateSteps,
                         },
-                        "categories":categories,
+                        "categories": categories,
                         "evaluationStrictness": evaluationStrictness,
                         "grammarCheckOutput": grammarCheckOutput,
                         "insightLength": insightLength,
@@ -786,7 +852,7 @@ class LlumoClient:
                     },
                     "type": "EVAL",
                     "kpi": evalName,
-                    "fieldMappig":fieldMapping,
+                    "fieldMappig": fieldMapping,
                 }
 
                 query = ""
@@ -846,25 +912,23 @@ class LlumoClient:
         time.sleep(3)
         listener_thread.join()
 
-        
         rawResults = self.socket.getReceivedData()
-        
+
         # print("data from db #####################",dataFromDb)
         # Fix here: keep full keys, do not split keys
         receivedRowIDs = {key for item in rawResults for key in item.keys()}
         expectedRowIDs = set(rowIdMapping.keys())
-        missingRowIDs = expectedRowIDs - receivedRowIDs 
+        missingRowIDs = expectedRowIDs - receivedRowIDs
         # print("All expected keys:", expected_rowIDs)
         # print("All received keys:", received_rowIDs)
         # print("Missing keys:", len(missingRowIDs))
-        missingRowIDs=list(missingRowIDs)
+        missingRowIDs = list(missingRowIDs)
         if len(missingRowIDs) > 0:
-            dataFromDb=fetchData(workspaceID,activePlayground,missingRowIDs)
+            dataFromDb = fetchData(workspaceID, activePlayground, missingRowIDs)
             rawResults.extend(dataFromDb)
-            
-            
+
         self.evalData = rawResults
-            
+
         # Initialize dataframe columns for each eval
         for eval in evals:
             dataframe[eval] = None
@@ -879,14 +943,37 @@ class LlumoClient:
                     dataframe.at[index, evalName] = value.get("value")
                     dataframe.at[index, f"{evalName} Reason"] = value.get("reasoning")
 
+                    # Log the evaluation step
+                    if hasattr(self, "logEvalStep"):
+                        try:
+                            start_time = time.time()
+                            self.logEvalStep(
+                                stepName=f"EVAL-{evalName}",
+                                output=value.get("value"),
+                                context=row.get("context", ""),
+                                query=row.get("query", ""),
+                                messageHistory=row.get("messageHistory", ""),
+                                tools=row.get("tools", ""),
+                                intermediateSteps=row.get("intermediateSteps", ""),
+                                groundTruth=row.get("groundTruth", ""),
+                                analyticsScore=value.get("analyticsScore", {}),
+                                reasoning=value.get("reasoning", {}),
+                                classification=value.get("classification", {}),
+                                evalLabel=value.get("evalLabel", {}),
+                                latencyMs=int((time.time() - start_time) * 1000),
+                                status="SUCCESS",
+                                message="",
+                            )
+                        except Exception as e:
+                            print(f"Error logging eval step: {e}")
+
         self.socket.disconnect()
-        
 
         if createExperiment:
             pd.set_option("future.no_silent_downcasting", True)
             # df = dataframe.fillna("Some error occured").astype(object)
             with warnings.catch_warnings():
-                warnings.simplefilter(action='ignore', category=FutureWarning)
+                warnings.simplefilter(action="ignore", category=FutureWarning)
                 df = dataframe.fillna("Some error occurred").astype(str)
 
             df = dataframe.fillna("Some error occured").infer_objects(copy=False)
@@ -897,42 +984,60 @@ class LlumoClient:
                 promptText=prompt_template,
                 definationMapping=self.definationMapping,
                 outputColName=outputColName,
-                activePlayground= activePlayground,
-                customAnalytics=customAnalytics
+                activePlayground=activePlayground,
+                customAnalytics=customAnalytics,
             ):
                 print(
                     "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results."
                 )
                 if getDataFrame:
-                    return LlumoDataFrameResults(dataframe,evals=self.evals,evalData=self.evalData,definationMapping=self.definationMapping)
+                    return LlumoDataFrameResults(
+                        dataframe,
+                        evals=self.evals,
+                        evalData=self.evalData,
+                        definationMapping=self.definationMapping,
+                    )
                 else:
-                    data=dataframe.to_dict(orient="records")
-                    return LlumoDictResults(data,evals=self.evals,evalData=self.evalData,definationMapping=self.definationMapping)
+                    data = dataframe.to_dict(orient="records")
+                    return LlumoDictResults(
+                        data,
+                        evals=self.evals,
+                        evalData=self.evalData,
+                        definationMapping=self.definationMapping,
+                    )
 
         else:
             if getDataFrame:
-                return LlumoDataFrameResults(dataframe,evals=self.evals,evalData=self.evalData,definationMapping=self.definationMapping)
+                return LlumoDataFrameResults(
+                    dataframe,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
             else:
-                data=dataframe.to_dict(orient="records")
-                return LlumoDictResults(data,evals=self.evals,evalData=self.evalData,definationMapping=self.definationMapping)
+                data = dataframe.to_dict(orient="records")
+                return LlumoDictResults(
+                    data,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
 
-    
     def promptSweep(
         self,
         templates: List[str],
         data,
         model_aliases: List[AVAILABLEMODELS],
-        apiKey: str,
         evals=["Response Correctness"],
         toEvaluate: bool = False,
         createExperiment: bool = False,
-        getDataFrame=False
+        getDataFrame=False,
     ) -> pd.DataFrame:
         if isinstance(data, dict):
-                data = [data]
-            # Check if data is now a list of dictionaries
+            data = [data]
+        # Check if data is now a list of dictionaries
         if isinstance(data, list) and all(isinstance(item, dict) for item in data):
-            working_df= pd.DataFrame(data).astype(str)
+            working_df = pd.DataFrame(data).astype(str)
         else:
             raise ValueError("Data must be a dictionary or a list of dictionaries.")
         modelStatus = validateModels(model_aliases=model_aliases)
@@ -942,10 +1047,10 @@ class LlumoClient:
         self.validateApiKey()
         workspaceID = self.workspaceID
         email = self.email
-        executor = ModelExecutor(apiKey)
+        executor = ModelExecutor(self.apiKey)
         prompt_template = templates[0]
-        
-        working_df = self._outputForStream(working_df, model_aliases, prompt_template, apiKey)
+
+        working_df = self._outputForStream(working_df, model_aliases, prompt_template)
 
         # Optional evaluation
         outputEvalMapping = None
@@ -959,40 +1064,49 @@ class LlumoClient:
                 if not metricDependencies["status"]:
                     raise LlumoAIError.dependencyError(metricDependencies["message"])
 
-            working_df, outputEvalMapping = self._evaluateForStream(working_df, evals, model_aliases, prompt_template,generateOutput=True)
+            working_df, outputEvalMapping = self._evaluateForStream(
+                working_df, evals, model_aliases, prompt_template, generateOutput=True
+            )
         if createExperiment:
             # df = working_df.fillna("Some error occured").astype(object)
             with warnings.catch_warnings():
-                warnings.simplefilter(action='ignore', category=FutureWarning)
+                warnings.simplefilter(action="ignore", category=FutureWarning)
                 df = working_df.fillna("Some error occurred").astype(str)
             if createPlayground(
-                    email, workspaceID, df,
-                    promptText=prompt_template,
-                    definationMapping=self.definationMapping,
-                    evalOutputMap=outputEvalMapping
+                email,
+                workspaceID,
+                df,
+                promptText=prompt_template,
+                definationMapping=self.definationMapping,
+                evalOutputMap=outputEvalMapping,
             ):
                 print(
-                    "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results.")
-                
+                    "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results."
+                )
+
         else:
             if getDataFrame == True and toEvaluate == True:
-                return LlumoDataFrameResults(working_df, evals=self.evals, evalData=self.evalData,
-                                             definationMapping=self.definationMapping)
+                return LlumoDataFrameResults(
+                    working_df,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
 
             elif getDataFrame == False and toEvaluate == True:
                 data = working_df.to_dict(orient="records")
-                return LlumoDictResults(data, evals=self.evals, evalData=self.evalData,
-                                        definationMapping=self.definationMapping)
+                return LlumoDictResults(
+                    data,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
 
-            elif getDataFrame== True and toEvaluate == False:
+            elif getDataFrame == True and toEvaluate == False:
                 return working_df
 
-            elif getDataFrame == False and toEvaluate == False :
-                return working_df.to_dict(orient = "records")
-
-
-
-
+            elif getDataFrame == False and toEvaluate == False:
+                return working_df.to_dict(orient="records")
 
     # this function generates an output using llm and tools and evaluate that output
     def evaluateAgents(
@@ -1004,8 +1118,7 @@ class LlumoClient:
         evals=["Final Task Alignment"],
         prompt_template="Give answer for the given query: {{query}}",
         createExperiment: bool = False,
-        getDataFrame:bool = False
-
+        getDataFrame: bool = False,
     ):
         if isinstance(data, dict):
             data = [data]
@@ -1036,8 +1149,7 @@ class LlumoClient:
             evals=evals,
             prompt_template=prompt_template,
             createExperiment=createExperiment,
-            getDataFrame=getDataFrame
-
+            getDataFrame=getDataFrame,
         )
 
         return toolResponseDf
@@ -1057,9 +1169,8 @@ class LlumoClient:
         data,
         evals=["Final Task Alignment"],
         createExperiment: bool = False,
-        getDataFrame = False,
-        outputColName="output"
-
+        getDataFrame=False,
+        outputColName="output",
     ):
         if isinstance(data, dict):
             data = [data]
@@ -1086,8 +1197,7 @@ class LlumoClient:
                 prompt_template="Give answer for the given query: {{query}}",
                 outputColName=outputColName,
                 createExperiment=createExperiment,
-                getDataFrame = getDataFrame
-
+                getDataFrame=getDataFrame,
             )
             if createExperiment:
                 pass
@@ -1098,18 +1208,17 @@ class LlumoClient:
             raise e
 
     def ragSweep(
-            self,
-            data,
-            streamName: str,
-            queryColName: str = "query",
-            createExperiment: bool = False,
-            modelAliases=[],
-            apiKey="",
-            prompt_template="Give answer to the given: {{query}} using the context:{{context}}",
-            evals=["Context Utilization"],
-            toEvaluate=False,
-            generateOutput=True,
-            getDataFrame = False
+        self,
+        data,
+        streamName: str,
+        queryColName: str = "query",
+        createExperiment: bool = False,
+        modelAliases=[],
+        prompt_template="Give answer to the given: {{query}} using the context:{{context}}",
+        evals=["Context Utilization"],
+        toEvaluate=False,
+        generateOutput=True,
+        getDataFrame=False,
     ):
         if isinstance(data, dict):
             data = [data]
@@ -1119,13 +1228,21 @@ class LlumoClient:
         # Validate required parameters
         if generateOutput:
             if not modelAliases:
-                raise ValueError("Model aliases must be provided when generateOutput is True.")
-            if not apiKey or not isinstance(apiKey, str) or apiKey.strip() == "":
-                raise ValueError("Valid API key must be provided when generateOutput is True.")
+                raise ValueError(
+                    "Model aliases must be provided when generateOutput is True."
+                )
+            if (
+                not self.apiKey
+                or not isinstance(self.apiKey, str)
+                or self.apiKey.strip() == ""
+            ):
+                raise ValueError(
+                    "Valid API key must be provided when generateOutput is True."
+                )
 
         modelStatus = validateModels(model_aliases=modelAliases)
-        if modelStatus["status"]== False:
-            if len(modelAliases) ==  0:
+        if modelStatus["status"] == False:
+            if len(modelAliases) == 0:
                 raise LlumoAIError.providerError("No model selected.")
             else:
                 raise LlumoAIError.providerError(modelStatus["message"])
@@ -1139,7 +1256,7 @@ class LlumoClient:
         try:
             socketID = self.socket.connect(timeout=150)
         except Exception as e:
-            socketID="DummySocketID"
+            socketID = "DummySocketID"
         # waited_secs = 0
         # while not self.socket._connection_established.is_set():
         #     time.sleep(0.1)
@@ -1151,8 +1268,12 @@ class LlumoClient:
 
         # Check user credits
         userHits = checkUserHits(
-            self.workspaceID, self.hasSubscribed, self.trialEndDate,
-            self.subscriptionEndDate, self.hitsAvailable, len(working_df)
+            self.workspaceID,
+            self.hasSubscribed,
+            self.trialEndDate,
+            self.subscriptionEndDate,
+            self.hitsAvailable,
+            len(working_df),
         )
         if not userHits["success"]:
             raise LlumoAIError.InsufficientCredits(userHits["message"])
@@ -1178,7 +1299,7 @@ class LlumoClient:
                 "inactivity_timeout": 10,
                 "expected_results": expectedResults,
             },
-            daemon=True
+            daemon=True,
         )
         listener_thread.start()
 
@@ -1207,7 +1328,13 @@ class LlumoClient:
                 self.allBatches.append(currentBatch)
                 currentBatch = []
 
-        for batch in tqdm(self.allBatches, desc="Processing Batches", unit="batch", colour="magenta", ncols=80):
+        for batch in tqdm(
+            self.allBatches,
+            desc="Processing Batches",
+            unit="batch",
+            colour="magenta",
+            ncols=80,
+        ):
             try:
                 self.postDataStream(batch=batch, workspaceID=workspaceID)
                 time.sleep(3)
@@ -1236,7 +1363,9 @@ class LlumoClient:
 
         # Output generation
         if generateOutput == True:
-            working_df = self._outputForStream(working_df, modelAliases, prompt_template, apiKey)
+            working_df = self._outputForStream(
+                working_df, modelAliases, prompt_template
+            )
 
         # Optional evaluation
         outputEvalMapping = None
@@ -1250,58 +1379,78 @@ class LlumoClient:
                 if not metricDependencies["status"]:
                     raise LlumoAIError.dependencyError(metricDependencies["message"])
 
-            working_df, outputEvalMapping = self._evaluateForStream(working_df, evals, modelAliases, prompt_template,generateOutput)
+            working_df, outputEvalMapping = self._evaluateForStream(
+                working_df, evals, modelAliases, prompt_template, generateOutput
+            )
 
-        
         self.socket.disconnect()
         # Create experiment if required
         if createExperiment:
             # df = working_df.fillna("Some error occured").astype(object)
             with warnings.catch_warnings():
-                warnings.simplefilter(action='ignore', category=FutureWarning)
+                warnings.simplefilter(action="ignore", category=FutureWarning)
                 df = working_df.fillna("Some error occurred").astype(str)
             if createPlayground(
-                    email, workspaceID, df,
-                    queryColName=queryColName,
-                    dataStreamName=streamId,
-                    promptText=prompt_template,
-                    definationMapping=self.definationMapping,
-                    evalOutputMap=outputEvalMapping
+                email,
+                workspaceID,
+                df,
+                queryColName=queryColName,
+                dataStreamName=streamId,
+                promptText=prompt_template,
+                definationMapping=self.definationMapping,
+                evalOutputMap=outputEvalMapping,
             ):
                 print(
-                    "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results.")
+                    "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results."
+                )
                 if getDataFrame == True and toEvaluate == True:
-                    return LlumoDataFrameResults(working_df, evals=self.evals, evalData=self.evalData,
-                                             definationMapping=self.definationMapping)
+                    return LlumoDataFrameResults(
+                        working_df,
+                        evals=self.evals,
+                        evalData=self.evalData,
+                        definationMapping=self.definationMapping,
+                    )
 
                 elif getDataFrame == False and toEvaluate == True:
                     data = working_df.to_dict(orient="records")
-                    return LlumoDictResults(data, evals=self.evals, evalData=self.evalData,
-                                            definationMapping=self.definationMapping)
+                    return LlumoDictResults(
+                        data,
+                        evals=self.evals,
+                        evalData=self.evalData,
+                        definationMapping=self.definationMapping,
+                    )
 
-                elif getDataFrame== True and toEvaluate == False:
+                elif getDataFrame == True and toEvaluate == False:
                     return working_df
 
-                elif getDataFrame == False and toEvaluate == False :
-                    return working_df.to_dict(orient = "records")
+                elif getDataFrame == False and toEvaluate == False:
+                    return working_df.to_dict(orient="records")
         else:
             if getDataFrame == True and toEvaluate == True:
-                return LlumoDataFrameResults(working_df, evals=self.evals, evalData=self.evalData,
-                                             definationMapping=self.definationMapping)
+                return LlumoDataFrameResults(
+                    working_df,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
 
             elif getDataFrame == False and toEvaluate == True:
                 data = working_df.to_dict(orient="records")
-                return LlumoDictResults(data, evals=self.evals, evalData=self.evalData,
-                                        definationMapping=self.definationMapping)
+                return LlumoDictResults(
+                    data,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
 
-            elif getDataFrame== True and toEvaluate == False:
+            elif getDataFrame == True and toEvaluate == False:
                 return working_df
 
-            elif getDataFrame == False and toEvaluate == False :
-                return working_df.to_dict(orient = "records")
+            elif getDataFrame == False and toEvaluate == False:
+                return working_df.to_dict(orient="records")
 
-    def _outputForStream(self, df, modelAliases, prompt_template, apiKey):
-        executor = ModelExecutor(apiKey)
+    def _outputForStream(self, df, modelAliases, prompt_template):
+        executor = ModelExecutor(self.apiKey)
 
         for indx, row in df.iterrows():
             inputVariables = re.findall(r"{{(.*?)}}", prompt_template)
@@ -1314,21 +1463,25 @@ class LlumoClient:
 
                     provider = getProviderFromModel(model)
                     if provider == Provider.OPENAI:
-                        validateOpenaiKey(apiKey)
+                        validateOpenaiKey(self.apiKey)
                     elif provider == Provider.GOOGLE:
-                        validateGoogleKey(apiKey)
+                        validateGoogleKey(self.apiKey)
 
-                    filled_template = getInputPopulatedPrompt(prompt_template, inputDict)
-                    response = executor.execute(provider, model.value, filled_template, apiKey)
+                    filled_template = getInputPopulatedPrompt(
+                        prompt_template, inputDict
+                    )
+                    response = executor.execute(provider, model.value, filled_template)
                     df.at[indx, f"output_{i}"] = response
-                    
+
                 except Exception as e:
                     # df.at[indx, f"output_{i}"] = str(e)
                     raise e
 
         return df
 
-    def _evaluateForStream(self, df, evals, modelAliases, prompt_template, generateOutput):
+    def _evaluateForStream(
+        self, df, evals, modelAliases, prompt_template, generateOutput
+    ):
         dfWithEvals = df.copy()
         outputColMapping = {}
 
@@ -1344,7 +1497,7 @@ class LlumoClient:
                         outputColName=outputColName,
                         _tocheck=False,
                         getDataFrame=True,
-                        createExperiment=False
+                        createExperiment=False,
                     )
 
                     for evalMetric in evals:
@@ -1353,11 +1506,15 @@ class LlumoClient:
                         if scoreCol in res.columns:
                             res = res.rename(columns={scoreCol: f"{scoreCol}_{i}"})
                         if reasonCol in res.columns:
-                            res = res.rename(columns={reasonCol: f"{evalMetric}_{i} Reason"})
+                            res = res.rename(
+                                columns={reasonCol: f"{evalMetric}_{i} Reason"}
+                            )
 
                         outputColMapping[f"{scoreCol}_{i}"] = outputColName
 
-                    newCols = [col for col in res.columns if col not in dfWithEvals.columns]
+                    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:
@@ -1374,7 +1531,7 @@ class LlumoClient:
                     outputColName=outputColName,
                     _tocheck=False,
                     getDataFrame=True,
-                    createExperiment=False
+                    createExperiment=False,
                 )
                 for evalMetric in evals:
                     scoreCol = f"{evalMetric}"
@@ -1389,13 +1546,13 @@ class LlumoClient:
         return dfWithEvals, outputColMapping
 
     def runDataStream(
-            self,
-            data,
-            streamName: str,
-            queryColName: str = "query",
-            createExperiment: bool = False,
-            getDataFrame = False
-           ):
+        self,
+        data,
+        streamName: str,
+        queryColName: str = "query",
+        createExperiment: bool = False,
+        getDataFrame=False,
+    ):
 
         if isinstance(data, dict):
             data = [data]
@@ -1411,7 +1568,7 @@ class LlumoClient:
         try:
             socketID = self.socket.connect(timeout=150)
         except Exception as e:
-            socketID="DummySocketID"
+            socketID = "DummySocketID"
         # waited_secs = 0
         # while not self.socket._connection_established.is_set():
         #     time.sleep(0.1)
@@ -1423,8 +1580,12 @@ class LlumoClient:
 
         # Check user credits
         userHits = checkUserHits(
-            self.workspaceID, self.hasSubscribed, self.trialEndDate,
-            self.subscriptionEndDate, self.hitsAvailable, len(working_df)
+            self.workspaceID,
+            self.hasSubscribed,
+            self.trialEndDate,
+            self.subscriptionEndDate,
+            self.hitsAvailable,
+            len(working_df),
         )
         if not userHits["success"]:
             raise LlumoAIError.InsufficientCredits(userHits["message"])
@@ -1450,7 +1611,7 @@ class LlumoClient:
                 "inactivity_timeout": 10,
                 "expected_results": expectedResults,
             },
-            daemon=True
+            daemon=True,
         )
         listener_thread.start()
 
@@ -1479,7 +1640,13 @@ class LlumoClient:
                 self.allBatches.append(currentBatch)
                 currentBatch = []
 
-        for batch in tqdm(self.allBatches, desc="Processing Batches", unit="batch", colour="magenta", ncols=80):
+        for batch in tqdm(
+            self.allBatches,
+            desc="Processing Batches",
+            unit="batch",
+            colour="magenta",
+            ncols=80,
+        ):
             try:
                 self.postDataStream(batch=batch, workspaceID=workspaceID)
                 time.sleep(3)
@@ -1506,21 +1673,22 @@ class LlumoClient:
                     idx = rowIdMapping[compound_key]["index"]
                     working_df.at[idx, "context"] = value.get("value")
 
-
-
         self.socket.disconnect()
 
         # Create experiment if required
         if createExperiment:
             df = working_df.fillna("Some error occured").astype(object)
             if createPlayground(
-                    email, workspaceID, df,
-                    queryColName=queryColName,
-                    dataStreamName=streamId,
-                    definationMapping=self.definationMapping,
+                email,
+                workspaceID,
+                df,
+                queryColName=queryColName,
+                dataStreamName=streamId,
+                definationMapping=self.definationMapping,
             ):
                 print(
-                    "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results.")
+                    "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results."
+                )
                 if getDataFrame:
                     return working_df
 
@@ -1537,7 +1705,6 @@ class LlumoClient:
             # self.latestDataframe = working_df
             # return working_df
 
-
     def createExperiment(self, dataframe):
         try:
             self.validateApiKey()
@@ -1555,7 +1722,6 @@ class LlumoClient:
         workspaceID = None
         email = None
 
-     
         try:
             self.validateApiKey()
         except Exception as e:
@@ -1583,17 +1749,17 @@ class LlumoClient:
             # If successfully loaded, call createPlayground
             df = df.astype(str)
             if createPlayground(self.email, self.workspaceID, df):
-                
+
                 print(
                     "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results."
                 )
-                
+
                 return True
 
         except Exception as e:
             print(f"Error: {e}")
-            
-    def upload(self,data):
+
+    def upload(self, data):
         try:
             if isinstance(data, dict):
                 data = [data]
@@ -1613,7 +1779,6 @@ class LlumoClient:
             print(f"Error: {e}")
             return False
 
-
     def createExperimentWithEvals(
         self,
         data,
@@ -1621,7 +1786,7 @@ class LlumoClient:
         prompt_template="Give answer to the given query: {{query}} using the given context: {{context}}.",
         outputColName="output",
         createExperiment: bool = False,
-        getDataFrame:bool =False,
+        getDataFrame: bool = False,
         _tocheck=True,
     ):
         if isinstance(data, dict):
@@ -1631,27 +1796,31 @@ class LlumoClient:
         dataframe = pd.DataFrame(data).astype(str)
         workspaceID = None
         email = None
-        self.evalData=[]
-        self.evals=evals
+        self.evalData = []
+        self.evals = evals
         self.allBatches = []
         rowIdMapping = {}  # (rowID-columnID-columnID -> (index, evalName))
         self.validateApiKey(evalName=evals[0])
         if createExperiment:
-            activePlayground = str(createEvalPlayground(email=self.email, workspaceID=self.workspaceID))
-            
-        else:    
+            if playgroundID:
+                activePlayground = playgroundID
+            else:
+                activePlayground = str(
+                    createEvalPlayground(email=self.email, workspaceID=self.workspaceID)
+                )
+        else:
             activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
-                        "-", ""
-                    )        
+                "-", ""
+            )
         for evalName in evals:
             self.validateApiKey(evalName=evalName)
-        self.evalData =dataframe.to_dict(orient="records") 
+        self.evalData = dataframe.to_dict(orient="records")
         if createExperiment:
             print("heading to upload")
             pd.set_option("future.no_silent_downcasting", True)
             # df = dataframe.fillna("Some error occured").astype(object)
             with warnings.catch_warnings():
-                warnings.simplefilter(action='ignore', category=FutureWarning)
+                warnings.simplefilter(action="ignore", category=FutureWarning)
                 df = dataframe.fillna("Some error occurred").astype(str)
 
             df = dataframe.fillna("Some error occured").infer_objects(copy=False)
@@ -1662,20 +1831,30 @@ class LlumoClient:
                 promptText=prompt_template,
                 definationMapping=self.definationMapping,
                 outputColName=outputColName,
-                activePlayground= activePlayground
+                activePlayground=activePlayground,
             ):
                 print(
                     "LLUMO’s intuitive UI is ready—start exploring and experimenting with your logs now. Visit https://app.llumo.ai/evallm to see the results."
                 )
-                
+
         else:
             if getDataFrame:
-                return LlumoDataFrameResults(dataframe,evals=self.evals,evalData=self.evalData,definationMapping=self.definationMapping)
+                return LlumoDataFrameResults(
+                    dataframe,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
             else:
-                data=dataframe.to_dict(orient="records")
-                return LlumoDictResults(data,evals=self.evals,evalData=self.evalData,definationMapping=self.definationMapping)
+                data = dataframe.to_dict(orient="records")
+                return LlumoDictResults(
+                    data,
+                    evals=self.evals,
+                    evalData=self.evalData,
+                    definationMapping=self.definationMapping,
+                )
+
 
-    
 class SafeDict(dict):
     def __missing__(self, key):
         return ""