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

llumo/callbacks-0.py

@@ -0,0 +1,258 @@
+from langchain_core.callbacks.base import BaseCallbackHandler
+from typing import Any, Dict, List, Optional, Union
+import time
+import json
+from llumo.llumoSessionContext import  getSessionID, getLlumoRun
+from llumo.llumoSessionContext import LlumoSessionContext
+
+
+class LlumoCallbackHandler(BaseCallbackHandler):
+    """
+    LangChain callback handler that integrates with Llumo logging system.
+    Tracks LLM calls, tool usage, agent actions, and chains.
+    """
+
+    def __init__(self, logger):
+        self.logger = logger
+        self.start_times = {}  # Track start times for latency calculation
+        self.step_counters = {}  # Track step counts for agents
+
+    def _get_session_context(self) -> Optional[LlumoSessionContext]:
+        """Get the current Llumo session context from context variables."""
+        try:
+            session_id = getSessionID()
+            run = getLlumoRun()
+            if session_id and run:
+                # Create a temporary context object to access logging methods
+                ctx = LlumoSessionContext(self.logger, session_id)
+                return ctx
+        except Exception:
+            pass
+        return None
+
+    def _safe_serialize(self, obj: Any) -> str:
+        """Safely serialize objects to JSON string."""
+        try:
+            return json.dumps(obj, default=str, ensure_ascii=False)
+        except Exception:
+            return str(obj)
+
+    # LLM Callbacks
+    def on_llm_start(
+            self, serialized: Dict[str, Any], prompts: List[str], **kwargs: Any
+    ) -> None:
+        """Called when LLM starts generating."""
+        run_id = kwargs.get('run_id')
+        if run_id:
+            self.start_times[run_id] = time.time()
+
+        print("LLM started - prompts:", len(prompts))
+
+    def on_llm_new_token(self, token: str, **kwargs: Any) -> None:
+        """Called when LLM generates a new token."""
+        # Optional: Could be used for streaming token tracking
+        pass
+
+    def on_llm_end(self, response: Any, **kwargs: Any) -> None:
+        """Called when LLM finishes generating."""
+        ctx = self._get_session_context()
+        if not ctx:
+            print("No Llumo session context available")
+            return
+
+        run_id = kwargs.get('run_id')
+        start_time = self.start_times.pop(run_id, time.time())
+        latency_ms = int((time.time() - start_time) * 1000)
+
+        # Extract LLM response details
+        model = getattr(response, 'model_name', 'unknown')
+
+        # Get token usage if available
+        token_usage = getattr(response, 'llm_output', {}).get('token_usage', {})
+        input_tokens = token_usage.get('prompt_tokens', 0)
+        output_tokens = token_usage.get('completion_tokens', 0)
+
+        # Get the generated text
+        if hasattr(response, 'generations') and response.generations:
+            output_text = response.generations[0][0].text if response.generations[0] else ""
+        else:
+            output_text = str(response)
+
+        # Get the original prompt
+        prompts = kwargs.get('prompts', [''])
+        query = prompts[0] if prompts else ""
+
+        try:
+            ctx.logLlmStep(
+                stepName=f"LLM Call - {model}",
+                model=model,
+                provider="langchain",
+                inputTokens=input_tokens,
+                outputTokens=output_tokens,
+                temperature=kwargs.get('temperature', 0.7),
+                promptTruncated=False,
+                latencyMs=latency_ms,
+                query=query,
+                output=output_text,
+                status="SUCCESS",
+                message=""
+            )
+            print(f"Logged LLM step: {model} ({latency_ms}ms)")
+        except Exception as e:
+            print(f"Failed to log LLM step: {e}")
+
+    def on_llm_error(self, error: Exception, **kwargs: Any) -> None:
+        """Called when LLM encounters an error."""
+        ctx = self._get_session_context()
+        if not ctx:
+            return
+
+        run_id = kwargs.get('run_id')
+        start_time = self.start_times.pop(run_id, time.time())
+        latency_ms = int((time.time() - start_time) * 1000)
+
+        prompts = kwargs.get('prompts', [''])
+        query = prompts[0] if prompts else ""
+
+        try:
+            ctx.logLlmStep(
+                stepName="LLM Call - Error",
+                model="unknown",
+                provider="langchain",
+                inputTokens=0,
+                outputTokens=0,
+                temperature=0.7,
+                promptTruncated=False,
+                latencyMs=latency_ms,
+                query=query,
+                output="",
+                status="FAILURE",
+                message=str(error)
+            )
+            print(f"Logged LLM error: {error}")
+        except Exception as e:
+            print(f"Failed to log LLM error: {e}")
+
+    # Chain Callbacks
+    def on_chain_start(
+            self, serialized: Dict[str, Any], inputs: Dict[str, Any], **kwargs: Any
+    ) -> None:
+        pass
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        """Called when a chain ends."""
+        print("Chain execution completed")
+
+    def on_chain_error(self, error: Exception, **kwargs: Any) -> None:
+        """Called when a chain encounters an error."""
+        print(f"Chain error: {error}")
+
+    # Tool Callbacks
+    def on_tool_start(
+            self, serialized: Dict[str, Any], input_str: str, **kwargs: Any
+    ) -> None:
+        """Called when a tool starts."""
+        run_id = kwargs.get('run_id')
+        if run_id:
+            self.start_times[run_id] = time.time()
+
+        tool_name = serialized.get('name', 'Unknown Tool')
+        print(f"Tool started: {tool_name}")
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> None:
+        """Called when a tool ends."""
+        ctx = self._get_session_context()
+        if not ctx:
+            return
+
+        run_id = kwargs.get('run_id')
+        start_time = self.start_times.pop(run_id, time.time())
+        latency_ms = int((time.time() - start_time) * 1000)
+
+        # Extract tool info from kwargs
+        serialized = kwargs.get('serialized', {})
+        tool_name = serialized.get('name', 'Unknown Tool')
+        input_str = kwargs.get('input_str', '')
+
+        try:
+            ctx.logToolStep(
+                stepName=f"Tool - {tool_name}",
+                toolName=tool_name,
+                input={"input": input_str},
+                output=output,
+                latencyMs=latency_ms,
+                status="SUCCESS",
+                message=""
+            )
+            print(f"Logged tool step: {tool_name} ({latency_ms}ms)")
+        except Exception as e:
+            print(f"Failed to log tool step: {e}")
+
+    def on_tool_error(self, error: Exception, **kwargs: Any) -> None:
+        """Called when a tool encounters an error."""
+        ctx = self._get_session_context()
+        if not ctx:
+            return
+
+        run_id = kwargs.get('run_id')
+        start_time = self.start_times.pop(run_id, time.time())
+        latency_ms = int((time.time() - start_time) * 1000)
+
+        serialized = kwargs.get('serialized', {})
+        tool_name = serialized.get('name', 'Unknown Tool')
+        input_str = kwargs.get('input_str', '')
+
+        try:
+            ctx.logToolStep(
+                stepName=f"Tool - {tool_name} - Error",
+                toolName=tool_name,
+                input={"input": input_str},
+                output="",
+                latencyMs=latency_ms,
+                status="FAILURE",
+                message=str(error)
+            )
+            print(f"Logged tool error: {tool_name} - {error}")
+        except Exception as e:
+            print(f"Failed to log tool error: {e}")
+
+    # Agent Callbacks
+    def on_agent_action(self, action: Any, **kwargs: Any) -> None:
+        """Called when an agent takes an action."""
+        run_id = kwargs.get('run_id')
+
+        # Track agent step count
+        if run_id not in self.step_counters:
+            self.step_counters[run_id] = 0
+        self.step_counters[run_id] += 1
+
+        print(f"Agent action: {getattr(action, 'tool', 'unknown')}")
+
+    def on_agent_finish(self, finish: Any, **kwargs: Any) -> None:
+        """Called when an agent finishes."""
+        ctx = self._get_session_context()
+        if not ctx:
+            return
+
+        run_id = kwargs.get('run_id')
+        num_steps = self.step_counters.pop(run_id, 0)
+
+        try:
+            ctx.logAgentStep(
+                stepName="Agent Execution",
+                agentType="langchain_agent",
+                agentName="LangChain Agent",
+                numStepsTaken=num_steps,
+                tools=[],  # Could be populated if tool info is available
+                query=getattr(finish, 'log', ''),
+                status="SUCCESS",
+                message=""
+            )
+            print(f"Logged agent finish: {num_steps} steps")
+        except Exception as e:
+            print(f"Failed to log agent step: {e}")
+
+
+
+
+

llumo/client.py

@@ -99,11 +99,23 @@ class LlumoClient:
             )
             self.email = data["data"]["data"].get("email", None)
 
-            self.definationMapping[evalName] = data.get("data", {}).get("data", {}).get("analyticsMapping", {}).get(evalName, 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", [])
+           
+            
         except Exception as e:
             # print(f"Error extracting data from response: {str(e)}")
-            raise LlumoAIError.UnexpectedError(detail=str(e))
+            raise LlumoAIError.UnexpectedError(detail=evalName)
 
     def postBatch(self, batch, workspaceID):
         payload = {
@@ -617,10 +629,12 @@ class LlumoClient:
         self,
         data,
         evals: list,  # list of eval metric names
+        session,  # Add session parameter
         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,
         _tocheck=True,
     ):
         if isinstance(data, dict):
@@ -668,19 +682,20 @@ 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(
-                        "-", ""
-                    )        
+            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:
             # print(f"\n======= Running evaluation for: {evalName} =======")
 
             # Validate API and dependencies
             self.validateApiKey(evalName=evalName)
+            customAnalytics=getCustomAnalytics(self.workspaceID)
             metricDependencies = checkDependency(
-                evalName, list(dataframe.columns), tocheck=_tocheck
+                evalName, list(dataframe.columns), tocheck=_tocheck,customevals=customAnalytics
             )
             if not metricDependencies["status"]:
                 raise LlumoAIError.dependencyError(metricDependencies["message"])
@@ -691,6 +706,15 @@ 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
+            
 
             userHits = checkUserHits(
                 self.workspaceID,
@@ -732,31 +756,39 @@ class LlumoClient:
                 templateData = {
                     "processID": getProcessID(),
                     "socketID": socketID,
+                    "rowID": rowID,
+                    "columnID": columnID,
+                    "processType": "EVAL",
+                    "evalType": evalType,
+                    "workspaceID": workspaceID,
+                    "email": email,
+                    "playgroundID": activePlayground,
                     "source": "SDK",
                     "processData": {
+                        "analyticsName": evalName,
+                        "definition": evalDefinition,
                         "executionDependency": {
-                            "query": "",
-                            "context": "",
-                            "output": output,
-                            "tools": tools,
-                            "groundTruth": groundTruth,
-                            "messageHistory": messageHistory,
-                            "intermediateSteps": intermediateSteps,
+                            "Query": "",
+                            "Context": "",
+                            "Output": output,
+                            "Tools": tools,
+                            "GroundTruth": groundTruth,
+                            "MessageHistory": messageHistory,
+                            "IntermediateSteps": intermediateSteps,
                         },
-                        "definition": evalDefinition,
+                        "categories":categories,
+                        "evaluationStrictness": evaluationStrictness,
+                        "grammarCheckOutput": grammarCheckOutput,
+                        "insightLength": insightLength,
+                        "numJudges": numJudges,
+                        "penaltyBonusInstructions": penaltyBonusInstructions,
+                        "probableEdgeCases": probableEdgeCases,
                         "model": model,
                         "provider": provider,
-                        "analytics": evalName,
                     },
-                    "workspaceID": workspaceID,
                     "type": "EVAL",
-                    "evalType": evalType,
                     "kpi": evalName,
-                    "columnID": columnID,
-                    "rowID": rowID,
-                    "playgroundID": activePlayground,
-                    "processType": "EVAL",
-                    "email": email,
+                    "fieldMappig":fieldMapping,
                 }
 
                 query = ""
@@ -828,7 +860,6 @@ class LlumoClient:
         # print("All received keys:", received_rowIDs)
         # print("Missing keys:", len(missingRowIDs))
         missingRowIDs=list(missingRowIDs)
-        
         if len(missingRowIDs) > 0:
             dataFromDb=fetchData(workspaceID,activePlayground,missingRowIDs)
             rawResults.extend(dataFromDb)
@@ -850,6 +881,30 @@ class LlumoClient:
                     dataframe.at[index, evalName] = value.get("value")
                     dataframe.at[index, f"{evalName} Reason"] = value.get("reasoning")
 
+                    # Log the evaluation step
+                    if session:
+                        try:
+                            start_time = time.time()
+                            session.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()
         
 
@@ -868,7 +923,8 @@ class LlumoClient:
                 promptText=prompt_template,
                 definationMapping=self.definationMapping,
                 outputColName=outputColName,
-                activePlayground= activePlayground
+                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."
@@ -1607,8 +1663,10 @@ class LlumoClient:
         rowIdMapping = {}  # (rowID-columnID-columnID -> (index, evalName))
         self.validateApiKey(evalName=evals[0])
         if createExperiment:
-            activePlayground = str(createEvalPlayground(email=self.email, workspaceID=self.workspaceID))
-            
+            if playgroundID:
+                activePlayground = playgroundID
+            else:
+                activePlayground = str(createEvalPlayground(email=self.email, workspaceID=self.workspaceID))
         else:    
             activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace(
                         "-", ""

llumo/exceptions.py

@@ -22,8 +22,8 @@ class LlumoAIError(Exception):
         return LlumoAIError("The API response is not in valid JSON format")
 
     @staticmethod
-    def UnexpectedError(detail="An UnexpectedError error occurred"):
-        return LlumoAIError(f"UnexpectedError error: {detail}")
+    def UnexpectedError(detail="Metric"):
+        return LlumoAIError(f"Can you please check if {detail} is written correctly. If you want to run {detail} please create a custom eval with same name of app.llumo.ai/evallm ")
 
     @staticmethod
     def EvalError(detail="Some error occured while processing"):

llumo/helpingFuntions.py

@@ -26,6 +26,7 @@ uploadRowList = (
 )
 createInsightUrl="https://app.llumo.ai/api/external/generate-insight-from-eval-for-sdk"
 
+getCustomAnalyticsUrl="https://app.llumo.ai/api/workspace/get-all-analytics"
 
 def getProcessID():
     return f"{int(time.time() * 1000)}{uuid.uuid4()}"
@@ -217,7 +218,7 @@ def deleteColumnListInPlayground(workspaceID: str, playgroundID: str):
         return None
 
 def createColumn(workspaceID, dataframe, playgroundID, promptText=None,queryColName=None,
-                 outputColName= "output",dataStreamName=None,definationMapping=None,evalOutputMap = None):
+                 outputColName= "output",dataStreamName=None,definationMapping=None,evalOutputMap = None,customAnalytics=[]):
     if len(dataframe) > 100:
         dataframe = dataframe.head(100)
         print("⚠️ Dataframe truncated to 100 rows for upload.")
@@ -228,9 +229,12 @@ def createColumn(workspaceID, dataframe, playgroundID, promptText=None,queryColN
         "columnListToUpload": [],
     }
     allEvals = ['Response Completeness', 'Response Bias', 'Response Harmfulness', 'Input Toxicity', 'Input Harmfulness', 'Context Utilization', 'Relevance Retention', 'Semantic Cohesion', 'Final Task Alignment', 'Tool Reliability', 'Response Correctness', 'Response Toxicity', 'Input Bias', 'Input Relevancy', 'Redundancy Reduction', 'Response Sentiment', 'Tool Selection Accuracy', 'Stepwise Progression', 'Hallucination', 'Faithfulness', 'Answer Relevancy', 'Context Precision', 'Answer Similarity', 'Harmfulness', 'Maliciousness', 'Coherence', 'Answer Correctness', 'Context Recall', 'Context Entity Recall', 'Conciseness', 'customEvalColumn', 'Groundedness', 'Memory Utilization', 'Input Relevancy (Multi-turn)','PII Check','Prompt Injection']
-
-    evalDependencies =  checkDependency(_returnDepMapping=True)
-
+    try:
+        allEvals.extend(list(customAnalytics.keys()))
+    except Exception as e:
+        pass
+    evalDependencies =  checkDependency(_returnDepMapping=True,customevals=customAnalytics)
+    print(allEvals)
     # Create a mapping of column names to unique column IDs
     columnIDMapping = {}
 
@@ -296,7 +300,7 @@ def createColumn(workspaceID, dataframe, playgroundID, promptText=None,queryColN
                     "order": indx}
 
 
-        elif any(col.startswith(eval + "_") or col == eval for eval in allEvals) and not " Reason" in col and promptText is not None:
+        elif any(col.startswith(eval + "_") or col == eval for eval in allEvals) and not " Reason" in col and promptText is not None :
             if evalOutputMap != None:
                 outputColName = evalOutputMap[col]
             else:
@@ -455,14 +459,14 @@ def uploadRowsInDBPlayground(payload):
         return None
 
 
-def createPlayground(email, workspaceID, df, promptText=None,queryColName=None,dataStreamName=None,definationMapping=None,outputColName="output",evalOutputMap = None,activePlayground=None):
+def createPlayground(email, workspaceID, df, promptText=None,queryColName=None,dataStreamName=None,definationMapping=None,outputColName="output",evalOutputMap = None,activePlayground=None,customAnalytics=[]):
     
     if activePlayground != None:
         playgroundId=activePlayground
     else:
         playgroundId = str(createEvalPlayground(email=email, workspaceID=workspaceID))
     payload1, payload2 = createColumn(
-        workspaceID=workspaceID, dataframe=df, playgroundID=playgroundId, promptText=promptText,queryColName=queryColName,dataStreamName=dataStreamName,definationMapping=definationMapping,outputColName=outputColName,evalOutputMap=evalOutputMap
+        workspaceID=workspaceID, dataframe=df, playgroundID=playgroundId, promptText=promptText,queryColName=queryColName,dataStreamName=dataStreamName,definationMapping=definationMapping,outputColName=outputColName,evalOutputMap=evalOutputMap,customAnalytics=customAnalytics
     )
     
  # Debugging line to check the payload2 structure
@@ -515,7 +519,7 @@ def getPlaygroundInsights(defination:str,uniqueClassesString: str, reasonList: l
     else:
         print(f"Error generating insight: {responseGenerate.status_code} - {responseGenerate.text}")
         return None
-def checkDependency(selectedEval:list = [], columns:list = [],tocheck=True,_returnDepMapping = False):
+def checkDependency(selectedEval:list = [], columns:list = [],tocheck=True,_returnDepMapping = False,customevals={}):
     """
     Checks if all the required input columns for the selected evaluation metric are present.
 
@@ -527,6 +531,7 @@ def checkDependency(selectedEval:list = [], columns:list = [],tocheck=True,_retu
     - LlumoAIError.dependencyError: If any required column is missing.
     """
     # Define required dependencies for each evaluation metric
+
     metricDependencies = {
         'Response Completeness': ['context', 'query', 'output'],
         'Response Bias': ['output'],
@@ -553,6 +558,8 @@ def checkDependency(selectedEval:list = [], columns:list = [],tocheck=True,_retu
         'PII Check':["query","output"],
         'Prompt Injection':["query"]
     }
+    
+    metricDependencies.update(customevals)
     if _returnDepMapping == True:
         return metricDependencies
 
@@ -652,6 +659,7 @@ def validateGoogleKey(api_key):
 
 def groupLogsByClass(logs, max_logs=2):
     # Initialize the final result structures (no defaultdict)
+    
     groupedLogs = {}
     uniqueEdgeCases = {}  # This will store unique edge cases for each eval_name
 
@@ -685,3 +693,46 @@ def groupLogsByClass(logs, max_logs=2):
         uniqueEdgeCases[eval_name] = list(uniqueEdgeCases[eval_name])
 
     return groupedLogs, uniqueEdgeCases
+
+
+def getCustomAnalytics(workspaceID):
+    try:
+        url = getCustomAnalyticsUrl
+        payload = {
+            "workspaceID": workspaceID
+        }
+
+        headers = {
+            "Content-Type": "application/json"
+        }
+
+        response = requests.post(url, json=payload, headers=headers)
+        data=response.json()
+        customData=data.get("data","").get("analyticsCustom","")
+        customMapping = {
+            "QUERY": "query",
+            "CONTEXT": "context",
+            "OUTPUT": "output",
+            "MESSAGEHISTORY": "messageHistory",
+            "TOOLS": "tools",
+            "INTERMEDIATESTEPS": "intermediateSteps",
+            "GROUNDTRUTH": "groundTruth",
+        }
+
+        metricDependencies = {}
+        
+        
+
+        for eval in customData:
+            evalName = eval.get("analyticsName")
+            evalDependencyRaw = list(eval.get("variableMappings").values())
+            
+            # Replace each value using the custom mapping
+            evalDependency = [customMapping.get(val.upper(), val.lower()) for val in evalDependencyRaw]
+            
+            # Build the dict
+            metricDependencies[evalName] = evalDependency
+        return metricDependencies
+    
+    except Exception as e:
+        return {}

llumo/llumoLogger.py

@@ -0,0 +1,57 @@
+import requests
+
+
+class LLUMOLogger:
+    def __init__(self, apiKey: str, playground: str):
+        self.apiKey = apiKey
+        self.playground = playground
+        self.workspaceID = None
+        self.playgroundID = None
+        self.userEmailID = None
+        self._authenticate()
+
+    def _authenticate(self):
+        url = "https://app.llumo.ai/api/get-playground-name"
+        try:
+            response = requests.post(
+                url,
+                headers={
+                    "Authorization": f"Bearer {self.apiKey}",
+                    "Content-Type": "application/json",
+                },
+                json={"playgroundName": self.playground},
+                timeout=10,
+            )
+
+            response.raise_for_status()
+            res_json = response.json()
+
+            # Navigate into the nested "data" structure
+            inner_data = res_json.get("data", {}).get("data", {})
+
+            self.workspaceID = inner_data.get("workspaceID")
+            self.playgroundID = inner_data.get("playgroundID")
+            self.userEmailID = inner_data.get("createdBy")
+
+            if not self.workspaceID or not self.playgroundID:
+                raise RuntimeError(
+                    f"Invalid response: workspaceID or playgroundID missing. Full response: {res_json}"
+                )
+
+        except requests.exceptions.RequestException as req_err:
+            raise RuntimeError(
+                f"Network or HTTP error during authentication: {req_err}"
+            )
+        except ValueError as json_err:
+            raise RuntimeError(f"Invalid JSON in authentication response: {json_err}")
+        except Exception as e:
+            raise RuntimeError(f"Authentication failed: {e}")
+
+    def getWorkspaceID(self):
+        return self.workspaceID
+
+    def getUserEmailID(self):
+        return self.userEmailID
+
+    def getPlaygroundID(self):
+        return self.playgroundID