llumo 0.2.35__tar.gz → 0.2.37__tar.gz

{llumo-0.2.35/llumo.egg-info → llumo-0.2.37}/PKG-INFO

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

{llumo-0.2.35 → llumo-0.2.37}/llumo/callback.py

@@ -4,6 +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.llumoSessionContext import LlumoSessionContext
 import time
@@ -16,6 +17,7 @@ class LlumoCallbackHandler(BaseCallbackHandler):
             raise ValueError("LlumoSessionContext is required")
 
         self.sessionLogger = session
+        self.sessionLogger.isLangchain = True
         self.agentType = agentType
 
         # Initialize timing and state variables
@@ -93,7 +95,7 @@ class LlumoCallbackHandler(BaseCallbackHandler):
 
                 self.agentStartTime = time.time()
                 self.isAgentExecution = True
-                print(f"[DEBUG] Agent execution started: {self.currentAgentName} - Reset counters for new query")
+                # print(f"[DEBUG] Agent execution started: {self.currentAgentName} - Reset counters for new query")
             else:
                 self.isAgentExecution = False
 
@@ -168,6 +170,10 @@ class LlumoCallbackHandler(BaseCallbackHandler):
 
     def on_llm_end(self, response: Any, **kwargs: Any) -> None:
         """Called when LLM completes"""
+        # print("ON LLM END kwargs: ",kwargs)
+        # print("ON LLM END response: ",response)
+
+
         duration_ms = int((time.time() - self.llmStartTime) * 1000) if self.llmStartTime else 0
 
         # Initialize default values
@@ -347,8 +353,8 @@ class LlumoCallbackHandler(BaseCallbackHandler):
 
     def on_tool_start(self, serialized: Dict[str, Any], input_str: str, **kwargs: Any) -> None:
         """Called when a tool starts executing"""
-        # print("ON TOOL START: ",serialized)
-        # print("ON TOOL START: ",kwargs)
+        # print("ON TOOL START serialized: ",serialized)
+        # print("ON TOOL START kwargs: ",kwargs)
 
         self.toolStartTime = time.time()
         self.stepTime = time.time()
@@ -376,7 +382,7 @@ class LlumoCallbackHandler(BaseCallbackHandler):
         if self.currentToolName not in self.toolsUsed:
             self.toolsUsed.append(self.currentToolName)
 
-        print(f"[DEBUG] Tool started: {self.currentToolName} with input: {input_str}")
+        # print(f"[DEBUG] Tool started: {self.currentToolName} with input: {input_str}")
 
     def on_tool_end(self, output: Any, **kwargs: Any) -> None:
         """Called when a tool completes execution"""
@@ -409,7 +415,7 @@ class LlumoCallbackHandler(BaseCallbackHandler):
                 status="SUCCESS",
                 # message="",
             )
-            print(f"[DEBUG] Tool completed: {self.currentToolName} -> {output_str}")
+            # print(f"[DEBUG] Tool completed: {self.currentToolName} -> {output_str}")
 
         except Exception as e:
             print(f"[ERROR] Failed to log tool end: {e}")
@@ -500,7 +506,7 @@ class LlumoCallbackHandler(BaseCallbackHandler):
                 toolName=self.currentToolName or "unknown",
                 description=self.currentToolDescription,
                 input=self.currentToolInput or {"input": ""},
-                output="",
+                output=f'{error}' if error else "",
                 latencyMs=0,
                 status="FAILURE",
                 # message=str(error),
@@ -557,7 +563,7 @@ class LlumoCallbackHandler(BaseCallbackHandler):
         """Called when arbitrary text is logged"""
         # Only log significant text events during agent execution
         if self.isAgentExecution and text.strip():
-            print(f"[DEBUG] Additional text: {text}")
+            # print(f"[DEBUG] Additional text: {text}")
 
             # Check if this text contains important ReAct information like "Observation:"
             if any(keyword in text.lower() for keyword in ['observation:']):

{llumo-0.2.35 → llumo-0.2.37}/llumo/client.py

@@ -1,12 +1,14 @@
 import requests
 
-
+import math
+import random
 import time
 import re
 import json
 import uuid
 import warnings
 import os
+
 import itertools
 import pandas as pd
 from typing import List, Dict
@@ -19,6 +21,7 @@ from .functionCalling import LlumoAgentExecutor
 from .chains import LlumoDataFrameResults, LlumoDictResults
 import threading
 from tqdm import tqdm
+from datetime import datetime, timezone
 
 pd.set_option("future.no_silent_downcasting", True)
 
@@ -773,99 +776,30 @@ class LlumoClient:
 
         return dataframe
 
-    def evaluateMultiple(
-        self,
-        data,
-        evals: list = [],
-        # prompt_template="Give answer to the given query: {{query}} using the given context: {{context}}.",
-        prompt_template="",
-        getDataFrame: bool = False,
-        _tocheck=True,
+    def debugLogs(
+            self,
+            data,
+            prompt_template="",
+
     ):
-        # if hasattr(self, "startLlumoRun"):
-        #     self.startLlumoRun(runName="evaluateMultiple")
         if isinstance(data, dict):
             data = [data]
         elif not isinstance(data, list):
             raise ValueError("Data should be a dict or a list of dicts.")
 
-        self.socket = LlumoSocketClient(socketUrl)
         dataframe = pd.DataFrame(data).astype(str)
         workspaceID = None
         email = None
-        try:
-            socketID = self.socket.connect(timeout=250)
-            print("Socket connected")
-            # print("Socket connected with ID:", socketID)
-        except Exception as e:
-            socketID = "DummySocketID"
-            print(f"Socket connection failed, using dummy ID. Error: {str(e)}")
 
-        self.evalData = []
-        self.evals = evals
-        self.allBatches = []
-        rowIdMapping = {}  # (rowID-columnID-columnID -> (index, evalName))
 
-        # Wait for socket connection
-        # max_wait_secs = 20
-        # waited_secs = 0
-        # while not self.socket._connection_established.is_set():
-        #     time.sleep(0.1)
-        #     waited_secs += 0.1
-        #     if waited_secs >= max_wait_secs:
-        #         raise RuntimeError("Timeout waiting for server connection")
-
-        # Start listener thread
-        # expectedResults = len(dataframe) * len(evals)
-        expectedResults = len(dataframe)
-        # print("expected result" ,expectedResults)
-        timeout = max(100, min(250, expectedResults * 60))
-        listener_thread = threading.Thread(
-            target=self.socket.listenForResults,
-            kwargs={
-                "min_wait": 20,
-                "max_wait": timeout,
-                "inactivity_timeout": timeout,
-                "expected_results": expectedResults,
-            },
-            daemon=True,
-        )
-        listener_thread.start()
         # commenting validate api key as we don't need it logger does it for us. uncommented but we need different
         # api for this which don't spend time on eval defintiion fetches and just bring hits
         self.validateApiKey()
         activePlayground = self.playgroundID
-        # print(f"\n======= Running evaluation for: {evalName} =======")
 
-        # Validate API and dependencies
-        # self.validateApiKey(evalName=evals[0])
-
-        # why we need custom analytics here? there is no such usage below
-        # customAnalytics = getCustomAnalytics(self.workspaceID)
-
-        # metricDependencies = checkDependency(
-        #     evalName,
-        #     list(dataframe.columns),
-        #     tocheck=_tocheck,
-        #     customevals=customAnalytics,
-        # )
-        # if not metricDependencies["status"]:
-        #     raise LlumoAIError.dependencyError(metricDependencies["message"])
 
-        # evalDefinition = self.evalDefinition[evalName]["definition"]
-        model = "GPT_4"
-        provider = "OPENAI"
-        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,
@@ -876,15 +810,13 @@ class LlumoClient:
             len(dataframe),
         )
 
-        #where does this remaining hit comes from?
+        # where does this remaining hit comes from?
 
-        
         if not userHits["success"]:
             raise LlumoAIError.InsufficientCredits(userHits["message"])
 
-        currentBatch = []
-        
-
+        sessionID = str(uuid.uuid4().hex[:16])
+        allBatches = []
         for index, row in dataframe.iterrows():
             # Extract required fields
             tools = row.get("tools", "")
@@ -892,19 +824,19 @@ class LlumoClient:
             messageHistory = row.get("messageHistory", "")
             intermediateSteps = row.get("intermediateSteps", "")
             output = row.get("output", "")
-            
+
             # Initialize query and context
             query = ""
             context = ""
-            
+
             # Process prompt template if provided
             if prompt_template:
                 # Extract template variables
                 keys = re.findall(r"{{(.*?)}}", prompt_template)
-                
+
                 if not all([key in dataframe.columns for key in keys]):
                     raise LlumoAIError.InvalidPromptTemplate()
-                
+
                 # Populate template and separate query/context
                 populated_template = prompt_template
                 for key in keys:
@@ -918,9 +850,9 @@ class LlumoClient:
                         else:
                             # Long value - add to context
                             context += f" {key}: {value}, "
-                
+
                 query = populated_template.strip()
-                
+
                 # Add any remaining context from other fields
                 if not context.strip():
                     for key, value in row.items():
@@ -930,159 +862,390 @@ class LlumoClient:
                 # No prompt template - use direct query and context fields
                 query = row.get("query", "")
                 context = row.get("context", "")
-            
-            # Generate unique IDs
+
+            INPUT_TOKEN_PRICE = 0.0000025
+            OUTPUT_TOKEN_PRICE = 0.00001
+            inputTokens = math.ceil(len(query)/ 4)
+            outputTokens = math.ceil(len(output) / 4)
+            totalTokens = inputTokens + outputTokens
+            cost = (inputTokens * INPUT_TOKEN_PRICE) + (outputTokens * OUTPUT_TOKEN_PRICE)
+
+            # compoundKey = f"{rowID}-{columnID}-{columnID}"
+            inputDict = {
+                 "query": query,
+                 "context": context.strip(),
+                 "output": output,
+                 "tools": tools,
+                 "groundTruth": groundTruth,
+                 "messageHistory": messageHistory,
+                 "intermediateSteps": intermediateSteps,
+                 "inputTokens": inputTokens,
+                 "outputTokens": outputTokens,
+                 "totalTokens": totalTokens,
+                 "cost": round(cost, 8),
+                 "modelsUsed": "gpt-4o",
+                 "latency":round(random.uniform(1,1.6),2)
+
+            }
+            currentTime = datetime(2025, 8, 2, 10, 20, 15, tzinfo=timezone.utc)
+            createdAt = currentTime.strftime("%Y-%m-%dT%H:%M:%S.000Z")
             rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
             columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
-            
-            compoundKey = f"{rowID}-{columnID}-{columnID}"
-            rowIdMapping[compoundKey] = {"index": index}
-            print("rowIdMapping:", rowIdMapping)
+            runID = str(uuid.uuid4().hex[:16])
 
-            # Create evaluation payload
-            # print("socketID in before templateData: ", socketID)
-            templateData = {
-                "processID": getProcessID(),
-                "socketID": socketID,
-                "rowID": rowID,
-                "columnID": columnID,
-                "processType": "FULL_EVAL_RUN",
-                "evalType": "LLM",
+
+            batch = {
+                "sessionID":sessionID,
                 "workspaceID": workspaceID,
-                "email": email,
                 "playgroundID": activePlayground,
-                "source": "SDK",
-                "processData": {
-                    "executionDependency": {
-                        "query": query,
-                        "context": context.strip(),
-                        "output": output,
-                        "tools": tools,
-                        "groundTruth": groundTruth,
-                        "messageHistory": messageHistory,
-                        "intermediateSteps": intermediateSteps,
-                    },
-                    "evallist": evals,
-                    "sessionID": self.sessionID
-                },
-                "type": "FULL_EVAL_RUN",
+                "logID": runID,
+                "format": "UPLOAD",
+                "logData": inputDict,
+                "userAim":[],
+                "source": "SDK_DEBUG_UPLOAD",
+                "email":email,
+                "createdBy": email,
+                "createdAt":createdAt,
+                "columnID":rowID,
+                "rowID":columnID,
+                "latency": random.randint(1000, 1500)
             }
 
-            # Add to batch
-            currentBatch.append(templateData)
-            if len(currentBatch) == 10:
-                self.allBatches.append(currentBatch)
-                currentBatch = []
+            allBatches.append(batch)
 
-        if currentBatch:
-            self.allBatches.append(currentBatch)
+        print(f"\nProcessing {len(allBatches)} records...")
+        for i, batch in enumerate(allBatches, start=1):
 
-        for batch in tqdm(
-            self.allBatches,
-            desc="Processing Batches",
-            unit="batch",
-            colour="magenta",
-            ascii=False,
-        ):
             try:
-                self.postBatch(batch=batch, workspaceID=workspaceID)
-                time.sleep(2)
                 # print(batch)
-            except Exception as e:
-                print(f"Error posting batch: {e}")
-                raise
+                response = postForListOfSteps(record=batch,workspaceID=workspaceID)
 
-        # Wait for results
-        time.sleep(3)
-        listener_thread.join()
+                # failure case inside response
+                if isinstance(response, dict) and str(response.get("status", "")).lower() == "false":
+                    error_msg = response.get("exception") or response.get("error") or "Unknown error"
+                    print(f"❌ Record {i} failed: {error_msg}")
 
-        rawResults = self.socket.getReceivedData()
-
-        # print(f"Total results received: {len(rawResults)}")
-        # print("Raw results:", rawResults)
-
-        # 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()}
-        # print("Received Row IDs:", receivedRowIDs)
-        expectedRowIDs = set(rowIdMapping.keys())
-        missingRowIDs = expectedRowIDs - receivedRowIDs
-        # print("All expected keys:", expectedRowIDs)
-        # print("All received keys:", receivedRowIDs)
-        # print("Missing keys:", len(missingRowIDs))
-        missingRowIDs = list(missingRowIDs)
-
-        # print("Missing Row IDs:", missingRowIDs)
-        # print(f"Total results before fetching missing data: {len(rawResults)}")
-        if len(missingRowIDs) > 0:
-            print('''It's taking longer than expected to get results for some rows. You can close this now. 
-                  Please wait for 15 mins while we create the flow graph for you. You can check the graph at app.llumo.ai/debugger''')
-        else:
-            print('''All results received successfully. You can check flowgraph in 5 mins at app.llumo.ai/debugger''')
-        # if len(missingRowIDs) > 0:
-        #     dataFromDb = self.fetchDataForMissingKeys(workspaceID, missingRowIDs)
-        #     # print("Fetched missing data from DB:", dataFromDb)
-        #     rawResults.extend(dataFromDb)
-        #     print(f"Total results after fetching missing data: {len(rawResults)}")
-        
-        self.evalData = rawResults
-        # print("RAW RESULTS: ", self.evalData)
-
-        # Initialize dataframe columns for each eval
-        for ev_name in evals:
-            dataframe[ev_name] = ""
-            dataframe[f"{ev_name} Reason"] = ""
-            # dataframe[f"{ev_name} EdgeCase"] = None
-
-        # Map results to dataframe rows
-        for item in rawResults:
-            for compound_key, value in item.items():
-                if compound_key not in rowIdMapping:
-                    continue
-                index = rowIdMapping[compound_key]["index"]
-                rowID, columnID, _ = compound_key.split("-", 2)
+                else:
+                    print(f"✅ Record {i} uploaded successfully.")
 
-                # get the dataframe row at this index
-                row = dataframe.iloc[index].to_dict()
+            except Exception as e:
+                print(f"❌ Record {i} failed: {e}")
 
-                if not value:
-                    continue
 
+        print("Records Uploaded successfully. You may now review the flow graph at: https://app.llumo.ai/all-debug")
 
-                # ️ Handle fullEval block
-                fullEval = value.get("fullEval") if isinstance(value, dict) else None
-                if fullEval:
-                    if "evalMetrics" in fullEval and isinstance(fullEval["evalMetrics"], list):
-                        for evalItem in fullEval["evalMetrics"]:
-                            evalName = evalItem.get("evalName") or evalItem.get("kpiName")
-                            score = str(evalItem.get("score")) or evalItem.get("value")
-                            reasoning = evalItem.get("reasoning")
-                            # edgeCase = eval_item.get("edgeCase")
-
-                            if evalName:
-                                dataframe.at[index, evalName] = score
-                                dataframe.at[index, f"{evalName} Reason"] = reasoning
-                                # dataframe.at[index, f"{evalName} EdgeCase"] = edgeCase
-
-                                
-                # runLog = value.get("runLog") if isinstance(value, dict) else None
-                # if runLog:
-                #     try:
-                #         self.createRunForEvalMultiple(smartLog=runLog)
-                #     except Exception as e:
-                #         print(f"Error posting smartlog: {e}")
-                        
 
-                
-        try:
-            self.socket.disconnect()
-        except Exception:
-            pass
+        # Wait for results
 
-        # if hasattr(self, "endLlumoRun"):
-        #     self.endEvalRun()
-        #
-        return dataframe
+    # def evaluateMultiple(
+    #     self,
+    #     data,
+    #     evals: list = [],
+    #     # prompt_template="Give answer to the given query: {{query}} using the given context: {{context}}.",
+    #     prompt_template="",
+    #     getDataFrame: bool = False,
+    #     _tocheck=True,
+    # ):
+    #     # if hasattr(self, "startLlumoRun"):
+    #     #     self.startLlumoRun(runName="evaluateMultiple")
+    #     if isinstance(data, dict):
+    #         data = [data]
+    #     elif not isinstance(data, list):
+    #         raise ValueError("Data should be a dict or a list of dicts.")
+    #
+    #     self.socket = LlumoSocketClient(socketUrl)
+    #     dataframe = pd.DataFrame(data).astype(str)
+    #     workspaceID = None
+    #     email = None
+    #     try:
+    #         socketID = self.socket.connect(timeout=250)
+    #         # print("Socket connected with ID:", socketID)
+    #     except Exception as e:
+    #         socketID = "DummySocketID"
+    #         # print(f"Socket connection failed, using dummy ID. Error: {str(e)}")
+    #
+    #     self.evalData = []
+    #     self.evals = evals
+    #     self.allBatches = []
+    #     rowIdMapping = {}  # (rowID-columnID-columnID -> (index, evalName))
+    #
+    #     # Wait for socket connection
+    #     # max_wait_secs = 20
+    #     # waited_secs = 0
+    #     # while not self.socket._connection_established.is_set():
+    #     #     time.sleep(0.1)
+    #     #     waited_secs += 0.1
+    #     #     if waited_secs >= max_wait_secs:
+    #     #         raise RuntimeError("Timeout waiting for server connection")
+    #
+    #     # Start listener thread
+    #     # expectedResults = len(dataframe) * len(evals)
+    #     expectedResults = len(dataframe)
+    #     # print("expected result" ,expectedResults)
+    #     timeout = max(100, min(250, expectedResults * 60))
+    #     listener_thread = threading.Thread(
+    #         target=self.socket.listenForResults,
+    #         kwargs={
+    #             "min_wait": 20,
+    #             "max_wait": timeout,
+    #             "inactivity_timeout": timeout,
+    #             "expected_results": expectedResults,
+    #         },
+    #         daemon=True,
+    #     )
+    #     listener_thread.start()
+    #     # commenting validate api key as we don't need it logger does it for us. uncommented but we need different
+    #     # api for this which don't spend time on eval defintiion fetches and just bring hits
+    #     self.validateApiKey()
+    #     activePlayground = self.playgroundID
+    #     # print(f"\n======= Running evaluation for: {evalName} =======")
+    #
+    #     # Validate API and dependencies
+    #     # self.validateApiKey(evalName=evals[0])
+    #
+    #     # why we need custom analytics here? there is no such usage below
+    #     # customAnalytics = getCustomAnalytics(self.workspaceID)
+    #
+    #     # metricDependencies = checkDependency(
+    #     #     evalName,
+    #     #     list(dataframe.columns),
+    #     #     tocheck=_tocheck,
+    #     #     customevals=customAnalytics,
+    #     # )
+    #     # if not metricDependencies["status"]:
+    #     #     raise LlumoAIError.dependencyError(metricDependencies["message"])
+    #
+    #     # evalDefinition = self.evalDefinition[evalName]["definition"]
+    #     model = "GPT_4"
+    #     provider = "OPENAI"
+    #     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,
+    #         self.hasSubscribed,
+    #         self.trialEndDate,
+    #         self.subscriptionEndDate,
+    #         self.hitsAvailable,
+    #         len(dataframe),
+    #     )
+    #
+    #     #where does this remaining hit comes from?
+    #
+    #
+    #     if not userHits["success"]:
+    #         raise LlumoAIError.InsufficientCredits(userHits["message"])
+    #
+    #     currentBatch = []
+    #
+    #
+    #     for index, row in dataframe.iterrows():
+    #         # Extract required fields
+    #         tools = row.get("tools", "")
+    #         groundTruth = row.get("groundTruth", "")
+    #         messageHistory = row.get("messageHistory", "")
+    #         intermediateSteps = row.get("intermediateSteps", "")
+    #         output = row.get("output", "")
+    #
+    #         # Initialize query and context
+    #         query = ""
+    #         context = ""
+    #
+    #         # Process prompt template if provided
+    #         if prompt_template:
+    #             # Extract template variables
+    #             keys = re.findall(r"{{(.*?)}}", prompt_template)
+    #
+    #             if not all([key in dataframe.columns for key in keys]):
+    #                 raise LlumoAIError.InvalidPromptTemplate()
+    #
+    #             # Populate template and separate query/context
+    #             populated_template = prompt_template
+    #             for key in keys:
+    #                 value = row.get(key, "")
+    #                 if isinstance(value, str):
+    #                     length = len(value.split()) * 1.5
+    #                     if length <= 50:
+    #                         # Short value - include in query via template
+    #                         temp_obj = {key: value}
+    #                         populated_template = getInputPopulatedPrompt(populated_template, temp_obj)
+    #                     else:
+    #                         # Long value - add to context
+    #                         context += f" {key}: {value}, "
+    #
+    #             query = populated_template.strip()
+    #
+    #             # Add any remaining context from other fields
+    #             if not context.strip():
+    #                 for key, value in row.items():
+    #                     if key not in keys and isinstance(value, str) and value.strip():
+    #                         context += f" {key}: {value}, "
+    #         else:
+    #             # No prompt template - use direct query and context fields
+    #             query = row.get("query", "")
+    #             context = row.get("context", "")
+    #
+    #         # Generate unique IDs
+    #         rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+    #         columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+    #
+    #         compoundKey = f"{rowID}-{columnID}-{columnID}"
+    #         rowIdMapping[compoundKey] = {"index": index}
+    #         # print("rowIdMapping:", rowIdMapping)
+    #
+    #         # Create evaluation payload
+    #         # print("socketID in before templateData: ", socketID)
+    #         templateData = {
+    #             "processID": getProcessID(),
+    #             "socketID": socketID,
+    #             "rowID": rowID,
+    #             "columnID": columnID,
+    #             "processType": "FULL_EVAL_RUN",
+    #             "evalType": "LLM",
+    #             "workspaceID": workspaceID,
+    #             "email": email,
+    #             "playgroundID": activePlayground,
+    #             "source": "SDK",
+    #             "processData": {
+    #                 "executionDependency": {
+    #                     "query": query,
+    #                     "context": context.strip(),
+    #                     "output": output,
+    #                     "tools": tools,
+    #                     "groundTruth": groundTruth,
+    #                     "messageHistory": messageHistory,
+    #                     "intermediateSteps": intermediateSteps,
+    #                 },
+    #                 "evallist": evals,
+    #                 "sessionID": self.sessionID
+    #             },
+    #             "type": "FULL_EVAL_RUN",
+    #         }
+    #
+    #         # Add to batch
+    #         currentBatch.append(templateData)
+    #         if len(currentBatch) == 10:
+    #             self.allBatches.append(currentBatch)
+    #             currentBatch = []
+    #
+    #     if currentBatch:
+    #         self.allBatches.append(currentBatch)
+    #
+    #     for batch in tqdm(
+    #         self.allBatches,
+    #         desc="Processing Batches",
+    #         unit="batch",
+    #         colour="magenta",
+    #         ascii=False,
+    #     ):
+    #         try:
+    #             self.postBatch(batch=batch, workspaceID=workspaceID)
+    #             time.sleep(2)
+    #             # print(batch)
+    #         except Exception as e:
+    #             print(f"Error posting batch: {e}")
+    #             raise
+    #
+    #     # Wait for results
+    #     time.sleep(3)
+    #     listener_thread.join()
+    #
+    #     rawResults = self.socket.getReceivedData()
+    #
+    #     # print(f"Total results received: {len(rawResults)}")
+    #     # print("Raw results:", rawResults)
+    #
+    #     # 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()}
+    #     # print("Received Row IDs:", receivedRowIDs)
+    #     expectedRowIDs = set(rowIdMapping.keys())
+    #     missingRowIDs = expectedRowIDs - receivedRowIDs
+    #     # print("All expected keys:", expectedRowIDs)
+    #     # print("All received keys:", receivedRowIDs)
+    #     # print("Missing keys:", len(missingRowIDs))
+    #     missingRowIDs = list(missingRowIDs)
+    #
+    #     # print("Missing Row IDs:", missingRowIDs)
+    #     # print(f"Total results before fetching missing data: {len(rawResults)}")
+    #     if len(missingRowIDs) > 0:
+    #         print('''It's taking longer than expected to get results for some rows. You can close this now.
+    #               Please wait for 15 mins while we create the flow graph for you. You can check the graph at app.llumo.ai/debugging''')
+    #     else:
+    #         print('''All results received successfully. You can check flowgraph in 5 mins at app.llumo.ai/debugging''')
+    #     # if len(missingRowIDs) > 0:
+    #     #     dataFromDb = self.fetchDataForMissingKeys(workspaceID, missingRowIDs)
+    #     #     # print("Fetched missing data from DB:", dataFromDb)
+    #     #     rawResults.extend(dataFromDb)
+    #     #     print(f"Total results after fetching missing data: {len(rawResults)}")
+    #
+    #     self.evalData = rawResults
+    #     # print("RAW RESULTS: ", self.evalData)
+    #
+    #     # Initialize dataframe columns for each eval
+    #     for ev_name in evals:
+    #         dataframe[ev_name] = ""
+    #         dataframe[f"{ev_name} Reason"] = ""
+    #         # dataframe[f"{ev_name} EdgeCase"] = None
+    #
+    #     # Map results to dataframe rows
+    #     for item in rawResults:
+    #         for compound_key, value in item.items():
+    #             if compound_key not in rowIdMapping:
+    #                 continue
+    #             index = rowIdMapping[compound_key]["index"]
+    #             rowID, columnID, _ = compound_key.split("-", 2)
+    #
+    #             # get the dataframe row at this index
+    #             row = dataframe.iloc[index].to_dict()
+    #
+    #             if not value:
+    #                 continue
+    #
+    #
+    #             # ️ Handle fullEval block
+    #             fullEval = value.get("fullEval") if isinstance(value, dict) else None
+    #             if fullEval:
+    #                 if "evalMetrics" in fullEval and isinstance(fullEval["evalMetrics"], list):
+    #                     for evalItem in fullEval["evalMetrics"]:
+    #                         evalName = evalItem.get("evalName") or evalItem.get("kpiName")
+    #                         score = str(evalItem.get("score")) or evalItem.get("value")
+    #                         reasoning = evalItem.get("reasoning")
+    #                         # edgeCase = eval_item.get("edgeCase")
+    #
+    #                         if evalName:
+    #                             dataframe.at[index, evalName] = score
+    #                             dataframe.at[index, f"{evalName} Reason"] = reasoning
+    #                             # dataframe.at[index, f"{evalName} EdgeCase"] = edgeCase
+    #
+    #
+    #             # runLog = value.get("runLog") if isinstance(value, dict) else None
+    #             # if runLog:
+    #             #     try:
+    #             #         self.createRunForEvalMultiple(smartLog=runLog)
+    #             #     except Exception as e:
+    #             #         print(f"Error posting smartlog: {e}")
+    #
+    #
+    #
+    #     try:
+    #         self.socket.disconnect()
+    #     except Exception:
+    #         pass
+    #
+    #     # if hasattr(self, "endLlumoRun"):
+    #     #     self.endEvalRun()
+    #     #
+    #     return dataframe
 
     def promptSweep(
         self,

{llumo-0.2.35 → llumo-0.2.37}/llumo/helpingFuntions.py

@@ -11,6 +11,7 @@ import re
 import openai
 import google.generativeai as genai
 from collections import defaultdict
+import requests
 
 
 from .models import  _MODEL_METADATA,  AVAILABLEMODELS
@@ -735,4 +736,30 @@ def getCustomAnalytics(workspaceID):
         return metricDependencies
     
     except Exception as e:
-        return {}
+        return {}
+
+
+
+def postForListOfSteps(record: {},workspaceID):
+    url = "https://backend-api.llumo.ai/api/v1/get-debug-log-for-upload"
+    payload = record
+    workspaceID = workspaceID
+
+    # Encode to Base64
+    workspaceIDEncoded = base64.b64encode(workspaceID.encode()).decode()
+
+    headers = {
+        "Authorization": f"Bearer {workspaceIDEncoded}",
+        "Content-Type": "application/json",
+    }
+
+    authorization = {}
+    # print("[PAYLOAD]: ",payload)
+    try:
+        response = requests.post(url=url, json=payload,headers = headers)
+        # print("[RESPONSE]: ",response.json())
+        # print()
+        return  {"status":"True","data":response.json()}
+
+    except Exception as e:
+        return  {"status":"False","exception": str(e)}

{llumo-0.2.35 → llumo-0.2.37}/llumo/llumoLogger.py

@@ -23,6 +23,12 @@ class LlumoLogger:
                 timeout=10,
             )
 
+            if response.status_code == 401:
+                # Wrong API key
+                print("❌ SDK integration failed! ")
+                raise Exception("Your Llumo API key is Invalid. Try again.")
+
+
             response.raise_for_status()
             res_json = response.json()
 
@@ -33,19 +39,19 @@ class LlumoLogger:
             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}"
-                )
-
+            # if not self.workspaceID or not self.playgroundID:
+            #     raise RuntimeError(
+            #         f"Invalid response: workspaceID or playgroundID missing. Full response: {res_json}"
+            #     )
+            print("✅ SDK integration successful! ")
         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}")
+        # 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

{llumo-0.2.35 → llumo-0.2.37}/llumo/llumoSessionContext.py

@@ -4,6 +4,10 @@ from typing import Optional, List, Dict, Any
 from datetime import datetime, timezone
 import requests
 from .client import LlumoClient
+import math
+import base64
+
+import random
 
 _ctxLogger = contextvars.ContextVar("ctxLogger")
 _ctxSessionID = contextvars.ContextVar("ctxSessionID")
@@ -31,6 +35,7 @@ class LlumoSessionContext(LlumoClient):
         self.threadLogger = None
         self.threadSessionID = None
         self.threadLlumoRun = None
+        self.isLangchain = False
 
     def start(self):
         self.threadLogger = _ctxLogger.set(self.logger)
@@ -68,25 +73,37 @@ class LlumoSessionContext(LlumoClient):
 
         currentTime = datetime(2025, 8, 2, 10, 20, 15, tzinfo=timezone.utc)
         createdAt = currentTime.strftime("%Y-%m-%dT%H:%M:%S.000Z")
+
+
+
         llumoRun = {
             "logID": LlumoRunID,
             "runName": runName,
             "sessionID": self.sessionID,
             "playgroundID": self.logger.getPlaygroundID(),
             "workspaceID": self.logger.getWorkspaceID(),
-            "source": "SDK",
+            "source": "SDK_LANGCHAIN" if self.isLangchain  else "SDK_OTHERS",
             "rowID": rowID,
             "columnID": columnID,
             "email": self.logger.getUserEmailID(),
             "createdAt": createdAt,
             "createdBy": self.logger.getUserEmailID(),
-            "status": "SUCCESS",
+            "status": "",
             "flow": [],
-            "latency": 4200,
             "feedback": "",
             "dump": "",
             "steps": [],
+            "format": "listofsteps",
+            "logData":{
+                "inputTokens": "",
+                "outputTokens":"",
+                "totalTokens": "",
+                "cost": "",
+                "modelsUsed": "gpt-4o",
+
+                       }
         }
+
         self.threadLlumoRun = _ctxLlumoRun.set(llumoRun)
 
     def endLlumoRun(self):
@@ -104,20 +121,59 @@ class LlumoSessionContext(LlumoClient):
         ]
         run["steps"] = clean_steps
 
+        llm_step = False
+        inputTokens = 0
+        outputTokens = 0
+        for item in run["steps"]:
+            if item.get("stepType") == "LLM":
+                llm_step = True
+                outputTokens = len(item["metadata"].get("output", 0)) / 4
+
+
+            if item.get("stepType") == "QUERY":
+                inputTokens = len(item["metadata"].get("query", 0)) / 4
+
+            # 2. If no LLM step, set zeros and continue
+        if llm_step == False:
+            run["logData"]["inputTokens"] = 0
+            run["logData"]["outputTokens"] = 0
+            run["logData"]["totalTokens"] = 0
+            run["logData"]["cost"] = 0
+            run["logData"]["modelsUsed"] = "gpt-4o"
+
+        INPUT_TOKEN_PRICE = 0.0000025
+        OUTPUT_TOKEN_PRICE = 0.00001
+        cost = (inputTokens * INPUT_TOKEN_PRICE) + (outputTokens * OUTPUT_TOKEN_PRICE)
+
+        run["logData"]["inputTokens"] = math.ceil(inputTokens)
+        run["logData"]["outputTokens"] = math.ceil(outputTokens)
+        run["logData"]["totalTokens"] = math.ceil(inputTokens + outputTokens)
+        run["logData"]["cost"] = round(cost, 8)
+        # run["latency"] = round(random.uniform(1,1.6),2)
         # print(run["runName"])  # optional debug log
 
         # STEP 3: Send the payload
-        url = "https://app.llumo.ai/api/create-debug-log"
+        # url = "https://app.llumo.ai/api/create-debug-log"
+        url = "https://backend-api.llumo.ai/api/v1/get-debug-log-for-New-SDK"
+        workspaceID =  self.logger.getWorkspaceID()
+
+        # Encode to Base64
+        workspaceIDEncoded = base64.b64encode(workspaceID.encode()).decode()
+
         headers = {
-            "Authorization": f"Bearer {self.logger.getWorkspaceID()}",
+            "Authorization": f"Bearer {workspaceIDEncoded}",
             "Content-Type": "application/json",
         }
 
+
+
         try:
-            # print(run)
-            response = requests.post(url, headers=headers, json=run, timeout=20)
+            # print("[PAYLOAD]: ",run)
+            payload = run
+            response = requests.post(url, headers=headers, json=payload, timeout=20)
             response.raise_for_status()
-            # print(response.json())
+            # print("[PAYLOAD]: ",response.json())
+
         except requests.exceptions.Timeout:
             # print("Request timed out.")
             pass

{llumo-0.2.35 → llumo-0.2.37}/llumo/sockets.py

@@ -110,7 +110,8 @@ class LlumoSocketClient:
         except Exception as e:
             # print(f"[DEBUG] Connection failed with error: {e}")
             self._connected = False
-            # raise RuntimeError(f"WebSocket connection failed: {e}")
+            # raise RuntimeError(f"WebSocket
+            # connection failed: {e}")
             print("It seems your internet connection is a bit unstable. This might take a little longer than usual—thanks for your patience!")
 
     def listenForResults(

{llumo-0.2.35 → llumo-0.2.37/llumo.egg-info}/PKG-INFO

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

{llumo-0.2.35 → llumo-0.2.37}/setup.py

@@ -39,6 +39,10 @@ def read_requirements():
             "tqdm==4.67.1",
             "google-generativeai==0.8.5",
             "websocket-client==1.8.0",
+            "pandas",
+            "python-dateutil",
+            "numpy",
+            "langchain_core",
             
         ]