llumo 0.2.25__py3-none-any.whl → 0.2.27__py3-none-any.whl

llumo/__init__.py

@@ -1,4 +1,4 @@
-from .client import LlumoClient
+
 from .exceptions import LlumoAIError
 from .helpingFuntions import *
 from .models import AVAILABLEMODELS

llumo/callback.py

@@ -4,7 +4,7 @@ from langchain_core.messages import BaseMessage
 from langchain_core.outputs import LLMResult
 from langchain_core.agents import AgentAction, AgentFinish
 import json
-from llumo.llumoLogger import LLUMOLogger
+from llumo.llumoLogger import LlumoLogger
 from llumo.llumoSessionContext import LlumoSessionContext
 import time
 import re

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,15 +699,15 @@ class LlumoClient:
     def evaluateMultiple(
         self,
         data,
-        evals: list,  # list of eval metric names
-        session,  # Add session parameter
+        evals: list,
         prompt_template="Give answer to the given query: {{query}} using the given context: {{context}}.",
         outputColName="output",
         createExperiment: bool = False,
-        getDataFrame:bool =False,
-        playgroundID: str = None,
+        getDataFrame: bool = False,
         _tocheck=True,
     ):
+        if hasattr(self, "startLlumoRun"):
+            self.startLlumoRun(runName="evaluateMultiple")
         if isinstance(data, dict):
             data = [data]
         elif not isinstance(data, list):
@@ -649,10 +720,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))
 
@@ -681,21 +752,18 @@ class LlumoClient:
         )
         listener_thread.start()
         self.validateApiKey(evalName=evals[0])
-        if createExperiment:
-            if playgroundID:
-                activePlayground = playgroundID
-            else:
-                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"])
@@ -706,15 +774,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,
@@ -746,7 +813,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("-", "")
 
@@ -776,7 +842,7 @@ class LlumoClient:
                             "MessageHistory": messageHistory,
                             "IntermediateSteps": intermediateSteps,
                         },
-                        "categories":categories,
+                        "categories": categories,
                         "evaluationStrictness": evaluationStrictness,
                         "grammarCheckOutput": grammarCheckOutput,
                         "insightLength": insightLength,
@@ -788,7 +854,7 @@ class LlumoClient:
                     },
                     "type": "EVAL",
                     "kpi": evalName,
-                    "fieldMappig":fieldMapping,
+                    "fieldMappig": fieldMapping,
                 }
 
                 query = ""
@@ -848,25 +914,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
@@ -882,10 +946,10 @@ class LlumoClient:
                     dataframe.at[index, f"{evalName} Reason"] = value.get("reasoning")
 
                     # Log the evaluation step
-                    if session:
+                    if hasattr(self, "logEvalStep"):
                         try:
                             start_time = time.time()
-                            session.logEvalStep(
+                            self.logEvalStep(
                                 stepName=f"EVAL-{evalName}",
                                 output=value.get("value"),
                                 context=row.get("context", ""),
@@ -906,13 +970,14 @@ class LlumoClient:
                             print(f"Error logging eval step: {e}")
 
         self.socket.disconnect()
-        
+        if hasattr(self, "endLlumoRun"):
+            self.endLlumoRun()
 
         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)
@@ -923,42 +988,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)
@@ -968,10 +1051,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
@@ -985,40 +1068,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(
@@ -1030,8 +1122,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]
@@ -1062,8 +1153,7 @@ class LlumoClient:
             evals=evals,
             prompt_template=prompt_template,
             createExperiment=createExperiment,
-            getDataFrame=getDataFrame
-
+            getDataFrame=getDataFrame,
         )
 
         return toolResponseDf
@@ -1083,9 +1173,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]
@@ -1112,8 +1201,7 @@ class LlumoClient:
                 prompt_template="Give answer for the given query: {{query}}",
                 outputColName=outputColName,
                 createExperiment=createExperiment,
-                getDataFrame = getDataFrame
-
+                getDataFrame=getDataFrame,
             )
             if createExperiment:
                 pass
@@ -1124,18 +1212,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]
@@ -1145,13 +1232,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"])
@@ -1165,7 +1260,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)
@@ -1177,8 +1272,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"])
@@ -1204,7 +1303,7 @@ class LlumoClient:
                 "inactivity_timeout": 10,
                 "expected_results": expectedResults,
             },
-            daemon=True
+            daemon=True,
         )
         listener_thread.start()
 
@@ -1233,7 +1332,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)
@@ -1262,7 +1367,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
@@ -1276,58 +1383,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)
@@ -1340,21 +1467,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 = {}
 
@@ -1370,7 +1501,7 @@ class LlumoClient:
                         outputColName=outputColName,
                         _tocheck=False,
                         getDataFrame=True,
-                        createExperiment=False
+                        createExperiment=False,
                     )
 
                     for evalMetric in evals:
@@ -1379,11 +1510,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:
@@ -1400,7 +1535,7 @@ class LlumoClient:
                     outputColName=outputColName,
                     _tocheck=False,
                     getDataFrame=True,
-                    createExperiment=False
+                    createExperiment=False,
                 )
                 for evalMetric in evals:
                     scoreCol = f"{evalMetric}"
@@ -1415,13 +1550,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]
@@ -1437,7 +1572,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)
@@ -1449,8 +1584,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"])
@@ -1476,7 +1615,7 @@ class LlumoClient:
                 "inactivity_timeout": 10,
                 "expected_results": expectedResults,
             },
-            daemon=True
+            daemon=True,
         )
         listener_thread.start()
 
@@ -1505,7 +1644,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)
@@ -1532,21 +1677,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
 
@@ -1563,7 +1709,6 @@ class LlumoClient:
             # self.latestDataframe = working_df
             # return working_df
 
-
     def createExperiment(self, dataframe):
         try:
             self.validateApiKey()
@@ -1581,7 +1726,6 @@ class LlumoClient:
         workspaceID = None
         email = None
 
-     
         try:
             self.validateApiKey()
         except Exception as e:
@@ -1609,17 +1753,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]
@@ -1639,7 +1783,6 @@ class LlumoClient:
             print(f"Error: {e}")
             return False
 
-
     def createExperimentWithEvals(
         self,
         data,
@@ -1647,7 +1790,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):
@@ -1657,8 +1800,8 @@ 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])
@@ -1666,20 +1809,22 @@ class LlumoClient:
             if playgroundID:
                 activePlayground = playgroundID
             else:
-                activePlayground = str(createEvalPlayground(email=self.email, workspaceID=self.workspaceID))
-        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)
@@ -1690,20 +1835,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 ""

llumo/llumoLogger.py

@@ -1,7 +1,7 @@
 import requests
 
 
-class LLUMOLogger:
+class LlumoLogger:
     def __init__(self, apiKey: str, playground: str):
         self.apiKey = apiKey
         self.playground = playground

llumo/llumoSessionContext.py

@@ -3,6 +3,7 @@ import uuid
 from typing import Optional, List, Dict, Any
 from datetime import datetime, timezone
 import requests
+from .client import LlumoClient
 
 _ctxLogger = contextvars.ContextVar("ctxLogger")
 _ctxSessionID = contextvars.ContextVar("ctxSessionID")
@@ -21,8 +22,9 @@ def getLlumoRun():
     return _ctxLlumoRun.get()
 
 
-class LlumoSessionContext:
+class LlumoSessionContext(LlumoClient):
     def __init__(self, logger, sessionID: Optional[str] = None):
+        super().__init__(api_key=logger.apiKey, playground_id=logger.getPlaygroundID())
         self.sessionID = sessionID or str(uuid.uuid4().hex[:14])
         self.logger = logger
         self.apiKey = logger.apiKey

llumo/openai.py

@@ -2,7 +2,7 @@ import time
 from openai import OpenAI as OpenAIClient
 from .client import LlumoClient
 from .llumoSessionContext import LlumoSessionContext
-from .llumoLogger import LLUMOLogger
+from .llumoLogger import LlumoLogger
 
 
 # evaluation function that uses LlumoClient
@@ -90,26 +90,26 @@ class OpenAI(OpenAIClient):
                 latency = int((time.time() - start_time) * 1000)
                 # Access the first result object
                 bias_evaluation = bias_evaluation_result[0]
-                # message = "-".join(
-                #     getattr(bias_evaluation, "edgeCases", {}).get("value", [])
-                # )
-                # self.session.logEvalStep(
-                #     stepName=f"EVAL-Input Bias",
-                #     output="",
-                #     context=context,
-                #     query=user_message,
-                #     messageHistory="",
-                #     tools="",
-                #     intermediateSteps="",
-                #     groundTruth="",
-                #     analyticsScore=getattr(bias_evaluation, "analyticsScore", {}),
-                #     reasoning=getattr(bias_evaluation, "reasoning", {}),
-                #     classification=getattr(bias_evaluation, "classification", {}),
-                #     evalLabel=getattr(bias_evaluation, "evalLabel", {}),
-                #     latencyMs=latency,
-                #     status="SUCCESS",
-                #     message=message,
-                # )
+                message = "-".join(
+                    getattr(bias_evaluation, "edgeCases", {}).get("value", [])
+                )
+                self.session.logEvalStep(
+                    stepName=f"EVAL-Input Bias",
+                    output="",
+                    context=context,
+                    query=user_message,
+                    messageHistory="",
+                    tools="",
+                    intermediateSteps="",
+                    groundTruth="",
+                    analyticsScore=getattr(bias_evaluation, "analyticsScore", {}),
+                    reasoning=getattr(bias_evaluation, "reasoning", {}),
+                    classification=getattr(bias_evaluation, "classification", {}),
+                    evalLabel=getattr(bias_evaluation, "evalLabel", {}),
+                    latencyMs=latency,
+                    status="SUCCESS",
+                    message=message,
+                )
             except Exception as e:
                 print(f"Input Bias evaluation failed: {e}")
                 self.session.logEvalStep(
@@ -171,30 +171,30 @@ class OpenAI(OpenAIClient):
                 latency = int((time.time() - start_time) * 1000)
                 # Access the first result object
                 correctness_evaluation = correctness_evaluation_result[0]
-                # message = "-".join(
-                #     getattr(correctness_evaluation, "edgeCases", {}).get("value", [])
-                # )
-                # self.session.logEvalStep(
-                #     stepName=f"EVAL-Response Correctness",
-                #     output=output_text,
-                #     context=context,
-                #     query=user_message,
-                #     messageHistory="",
-                #     tools="",
-                #     intermediateSteps="",
-                #     groundTruth="",
-                #     analyticsScore=getattr(
-                #         correctness_evaluation, "analyticsScore", {}
-                #     ),
-                #     reasoning=getattr(correctness_evaluation, "reasoning", {}),
-                #     classification=getattr(
-                #         correctness_evaluation, "classification", {}
-                #     ),
-                #     evalLabel=getattr(correctness_evaluation, "evalLabel", {}),
-                #     latencyMs=latency,
-                #     status="SUCCESS",
-                #     message=message,
-                # )
+                message = "-".join(
+                    getattr(correctness_evaluation, "edgeCases", {}).get("value", [])
+                )
+                self.session.logEvalStep(
+                    stepName=f"EVAL-Response Correctness",
+                    output=output_text,
+                    context=context,
+                    query=user_message,
+                    messageHistory="",
+                    tools="",
+                    intermediateSteps="",
+                    groundTruth="",
+                    analyticsScore=getattr(
+                        correctness_evaluation, "analyticsScore", {}
+                    ),
+                    reasoning=getattr(correctness_evaluation, "reasoning", {}),
+                    classification=getattr(
+                        correctness_evaluation, "classification", {}
+                    ),
+                    evalLabel=getattr(correctness_evaluation, "evalLabel", {}),
+                    latencyMs=latency,
+                    status="SUCCESS",
+                    message=message,
+                )
             except Exception as e:
                 print(f"Response Correctness evaluation failed: {e}")
                 correctness_evaluation = None

{llumo-0.2.25.dist-info → llumo-0.2.27.dist-info}/METADATA

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

llumo-0.2.27.dist-info/RECORD

@@ -0,0 +1,20 @@
+llumo/__init__.py,sha256=kkuppu7ZPiVZFdnYzJ9BM3syMbYHOSZLpwKwAvGHsnY,311
+llumo/callback.py,sha256=dOsQ35Ro6IVec3TiJfkPx3H9PQtk8oWfJA1skFENTIM,20439
+llumo/callbacks-0.py,sha256=TEIOCWRvk2UYsTmBMBsnlgpqWvr-2y3a6d0w_e96NRM,8958
+llumo/chains.py,sha256=6lCgLseh04RUgc6SahhmvQj82quay2Mi1j8gPUlx8Es,2923
+llumo/client.py,sha256=keYx0GToNB-FXmGncXd0MOwwCGjxsIoDbOhTx2rCcMQ,71582
+llumo/exceptions.py,sha256=1OyhN9YL9LcyUPUsqYHq6Rret0udATZAwMVJaio2_Ec,2123
+llumo/execution.py,sha256=nWbJ7AvWuUPcOb6i-JzKRna_PvF-ewZTiK8skS-5n3w,1380
+llumo/functionCalling.py,sha256=D5jYapu1rIvdIJNUYPYMTyhQ1H-6nkwoOLMi6eekfUE,7241
+llumo/google.py,sha256=3S_aRtbtlctCXPGR0u4baLlkyFrsjd02vlUCkoRPA5U,2147
+llumo/helpingFuntions.py,sha256=B6FwUQ5f1v4FKrWCbYoGWMFdscOV_liuuhTgNQ3cdrk,27275
+llumo/llumoLogger.py,sha256=grdjhu6Ngxg7nhnrMOP5Pd5ALR7U2ROws48yhf_N7y0,1912
+llumo/llumoSessionContext.py,sha256=v1OPJFYWe5-mLLUohX5qY7dlzgwmxpuRZ0rDsXEv6f4,10506
+llumo/models.py,sha256=aVEZsOOoQx5LeNtwSyBxqvrINq0izH3QWu_YjsMPE6o,2910
+llumo/openai.py,sha256=c0pZ-yzm6LfUAbfVmOiVpY9pS5sAWZRb8_jAj0ir910,8450
+llumo/sockets.py,sha256=pBDo-U65hMIMwKMwZQl3iBkEjISEt-9BkXxZTWfSHF4,6116
+llumo-0.2.27.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
+llumo-0.2.27.dist-info/METADATA,sha256=1zlTWFpTBkmDtAYsP9HbGfN2OQ7Xuy3t9Z7FM73k8W0,1558
+llumo-0.2.27.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+llumo-0.2.27.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
+llumo-0.2.27.dist-info/RECORD,,

llumo-0.2.25.dist-info/RECORD

@@ -1,20 +0,0 @@
-llumo/__init__.py,sha256=ZdFeOT5aDM1iA4VzQ8ryc0rxF3ihjhPO8aCRuw8t0zk,342
-llumo/callback.py,sha256=Pzg9Smqsu5G900YZjoFwqMY0TTP4jUizxllaP0TjKgk,20439
-llumo/callbacks-0.py,sha256=TEIOCWRvk2UYsTmBMBsnlgpqWvr-2y3a6d0w_e96NRM,8958
-llumo/chains.py,sha256=6lCgLseh04RUgc6SahhmvQj82quay2Mi1j8gPUlx8Es,2923
-llumo/client.py,sha256=RKI8XIIafzMWX42gXBXAcMjtOzZngx1ebgGfXmNDa-w,69064
-llumo/exceptions.py,sha256=1OyhN9YL9LcyUPUsqYHq6Rret0udATZAwMVJaio2_Ec,2123
-llumo/execution.py,sha256=nWbJ7AvWuUPcOb6i-JzKRna_PvF-ewZTiK8skS-5n3w,1380
-llumo/functionCalling.py,sha256=D5jYapu1rIvdIJNUYPYMTyhQ1H-6nkwoOLMi6eekfUE,7241
-llumo/google.py,sha256=3S_aRtbtlctCXPGR0u4baLlkyFrsjd02vlUCkoRPA5U,2147
-llumo/helpingFuntions.py,sha256=B6FwUQ5f1v4FKrWCbYoGWMFdscOV_liuuhTgNQ3cdrk,27275
-llumo/llumoLogger.py,sha256=UW3eIQb5txneilx8FQnGf6t4LgP85NoIf5YECFDZShk,1912
-llumo/llumoSessionContext.py,sha256=J4oFCWcpksZ2sWgGJqzq2LjUwIG1OAQva_EAvNy9ACs,10373
-llumo/models.py,sha256=aVEZsOOoQx5LeNtwSyBxqvrINq0izH3QWu_YjsMPE6o,2910
-llumo/openai.py,sha256=QyNMXiYTppaU_YjU6vU5UB0At3OiNntoDTQ0dszLN0g,8538
-llumo/sockets.py,sha256=pBDo-U65hMIMwKMwZQl3iBkEjISEt-9BkXxZTWfSHF4,6116
-llumo-0.2.25.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
-llumo-0.2.25.dist-info/METADATA,sha256=HkIJH54gwQ-rAgxzgpiCWVvvn6tD0jNPYJqnTAoZOfA,1558
-llumo-0.2.25.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-llumo-0.2.25.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
-llumo-0.2.25.dist-info/RECORD,,