llumo 0.1.8__py3-none-any.whl → 0.1.9b10__py3-none-any.whl

llumo/client.py

@@ -1,11 +1,12 @@
 import requests
+from docutils.nodes import subscript
+
 from .exceptions import LlumoAIError
 import time
 import re
 import json
 import uuid
 import threading
-from .helpingFuntions import *
 from dotenv import load_dotenv
 import os
 import itertools
@@ -13,6 +14,7 @@ import pandas as pd
 from typing import List, Dict
 from .models import AVAILABLEMODELS,getProviderFromModel
 from .execution import ModelExecutor
+from .helpingFuntions import *
 from .sockets import LlumoSocketClient
 from .functionCalling import LlumoAgentExecutor
 
@@ -21,9 +23,9 @@ from .functionCalling import LlumoAgentExecutor
 envPath = os.path.join(os.path.dirname(__file__), '.env')
 load_dotenv(dotenv_path=envPath, override=False)# Automatically looks for .env in current directory
 
-postUrl = os.getenv("postUrl")
-fetchUrl = os.getenv("fetchUrl")
-validateUrl = os.getenv("validateUrl")
+postUrl = os.getenv("POST_URL")
+fetchUrl = os.getenv("FETCH_URL")
+validateUrl = os.getenv("VALIDATE_URL")
 socketUrl = os.getenv("SOCKET_URL")
 
 
@@ -33,6 +35,7 @@ class LlumoClient:
         self.apiKey = api_key
         self.socket = LlumoSocketClient(socketUrl)
         self.processMapping = {}
+        
 
 
     def validateApiKey(self, evalName = ""):
@@ -99,6 +102,9 @@ class LlumoClient:
             self.workspaceID = data["data"].get("workspaceID")
             self.evalDefinition = data["data"].get("analyticsMapping")
             self.socketToken = data["data"].get("token")
+            self.hasSubscribed = data["data"].get("hasSubscribed",False)
+            self.trialEndDate = data["data"].get("trialEndDate",None)
+            self.subscriptionEndDate = data["data"].get("subscriptionEndDate", None)
 
             # print(f"API key validation successful:")
             # print(f"- Remaining hits: {self.hitsAvailable}")
@@ -115,6 +121,7 @@ class LlumoClient:
             "runType": "EVAL",
             "workspaceID": workspaceID,
         }
+        # socketToken here if the "JWD" token
         headers = {
             "Authorization": f"Bearer {self.socketToken}",
             "Content-Type": "application/json",
@@ -127,6 +134,28 @@ class LlumoClient:
 
         except Exception as e:
             print(f"Error in posting batch: {e}")
+    
+
+    def postDataStream(self, batch, workspaceID):
+        payload = {
+            "batch": json.dumps(batch),
+            "runType": "DATA_STREAM",
+            "workspaceID": workspaceID,
+        }
+        # socketToken here if the "JWD" token
+        headers = {
+            "Authorization": f"Bearer {self.socketToken}",
+            "Content-Type": "application/json",
+        }
+        try:
+            # print(postUrl)
+            response = requests.post(postUrl, json=payload, headers=headers)
+            # print(f"Post API Status Code: {response.status_code}")
+            # print(response.text)
+
+        except Exception as e:
+            print(f"Error in posting batch: {e}")
+    
 
     def AllProcessMapping(self):
         for batch in self.allBatches:
@@ -143,6 +172,7 @@ class LlumoClient:
 
         for item in results:
             for rowID in item:  # Each item has only one key
+            # for rowID in item["data"]:
                 if rowID not in seen:
                     seen.add(rowID)
                     uniqueResults.append(item)
@@ -175,9 +205,14 @@ class LlumoClient:
                 if hasattr(e, "response") and getattr(e, "response", None) is not None:
                     pass
                 raise
+            userHits = checkUserHits(self.workspaceID,self.hasSubscribed,self.trialEndDate,self.subscriptionEndDate,self.hitsAvailable,len(dataframe))
+
 
-            if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
-                raise LlumoAIError.InsufficientCredits()
+            if not userHits["success"]:
+                raise LlumoAIError.InsufficientCredits(userHits["message"])
+
+            # if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
+            #     raise LlumoAIError.InsufficientCredits()
 
             evalDefinition = self.evalDefinition[eval]
             model = "GPT_4"
@@ -206,6 +241,7 @@ class LlumoClient:
                 rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
                 columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
 
+                # storing the generated rowID and the row index (dataframe) for later lookkup
                 rowIdMapping[rowID] = index
 
                 templateData = {
@@ -298,10 +334,17 @@ class LlumoClient:
             dataframe[evalName] = None
             for item in records:
                 for compound_key, value in item.items():
+                # for compound_key, value in item['data'].items():
+
                     rowID = compound_key.split('-')[0]
+                    # looking for the index of each rowID , in the original dataframe
                     if rowID in rowIdMapping:
                         index = rowIdMapping[rowID]
-                        dataframe.at[index, evalName] = value
+                        # dataframe.at[index, evalName] = value
+                        dataframe.at[index, evalName] = value["value"]
+                        dataframe.at[index, f'{evalName} Reason'] = value["reasoning"]
+
+
                     else:
                         pass
                         # print(f"⚠️ Warning: Could not find rowID {rowID} in mapping")
@@ -338,8 +381,16 @@ class LlumoClient:
                     print(f"Response content: {e.response.text[:500]}...")
                 raise
 
-            if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
-                raise LlumoAIError.InsufficientCredits()
+            # check for available hits and trial limit
+            userHits = checkUserHits(self.workspaceID, self.hasSubscribed, self.trialEndDate, self.subscriptionEndDate,
+                                     self.hitsAvailable, len(dataframe))
+
+           # do not proceed if subscription or trial limit has exhausted
+            if not userHits["success"]:
+                raise LlumoAIError.InsufficientCredits(userHits["message"])
+
+            # if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
+            #     raise LlumoAIError.InsufficientCredits()
 
             model = "GPT_4"
             provider = "OPENAI"
@@ -555,7 +606,177 @@ class LlumoClient:
             )
         return toolResponseDf
 
+    def evaluateAgentResponses(self, dataframe, prompt_template="Give answer for the given query: {{query}}"):
+        try:
+            if "query" and "messageHistory" and "tools" not in dataframe.columns:
+                raise ValueError("DataFrame must contain 'query', 'messageHistory', and 'tools' columns")
+            evals = ["Tool Reliability", "Stepwise Progression", "Tool Selection Accuracy", "Final Task Alignment"]
+            toolResponseDf = dataframe.copy()
+            for eval in evals:
+                # Perform evaluation
+                toolResponseDf = self.evaluate(
+                    toolResponseDf,
+                    eval = eval,
+                    prompt_template=prompt_template
+                )
+            return toolResponseDf
+            
+        except Exception as e:
+            raise e
+    
+    def runDataStream(self, dataframe, streamName:str,queryColName:str="query"):
+        results = {}
+        
+        try:
+            socketID = self.socket.connect(timeout=150)
+            # Ensure full connection before proceeding
+            max_wait_secs = 20
+            waited_secs = 0
+            while not self.socket._connection_established.is_set():
+                time.sleep(0.1)
+                waited_secs += 0.1
+                if waited_secs >= max_wait_secs:
+                    raise RuntimeError("Timeout waiting for server 'connection-established' event.")
+            # print(f"Connected with socket ID: {socketID}")
+            rowIdMapping = {}
+            try:
+                # print(f"Validating API key...")
+                self.validateApiKey()
+                # print(f"API key validation successful. Hits available: {self.hitsAvailable}")
+            except Exception as e:
+                print(f"Error during API key validation: {str(e)}")
+                if hasattr(e, "response") and getattr(e, "response", None) is not None:
+                    print(f"Status code: {e.response.status_code}")
+                    print(f"Response content: {e.response.text[:500]}...")
+                raise
+            # check for available hits and trial limit
+            userHits = checkUserHits(self.workspaceID, self.hasSubscribed, self.trialEndDate, self.subscriptionEndDate,
+                                     self.hitsAvailable, len(dataframe))
+
+           # do not proceed if subscription or trial limit has exhausted
+            if not userHits["success"]:
+                raise LlumoAIError.InsufficientCredits(userHits["message"])
+
+            
 
+            print("====🚀Sit back while we fetch data from the stream 🚀====")
+            workspaceID = self.workspaceID
+            streamId=getStreamId(workspaceID,self.apiKey,streamName)
+            # Prepare all batches before sending
+            # print("Preparing batches...")
+            self.allBatches = []
+            currentBatch = []
+
+            for index, row in dataframe.iterrows():
+                activePlayground = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                rowID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+                columnID = f"{int(time.time() * 1000)}{uuid.uuid4()}".replace("-", "")
+
+                rowIdMapping[rowID] = index
+                # Use the server-provided socket ID here
+                templateData = {
+                    "processID": getProcessID(),
+                    "socketID": socketID,
+                    "processData": {
+                        "executionDependency": {
+                            "query": row[queryColName]
+                        },
+                        "dataStreamID": streamId
+                    },
+                    "workspaceID": workspaceID,
+                    "email": "",
+                    "type": "DATA_STREAM",
+                    "playgroundID": activePlayground,
+                    "processType": "DATA_STREAM",
+                    "rowID": rowID,
+                    "columnID": columnID,
+                    "source": "SDK"
+   
+                }
+
+
+                currentBatch.append(templateData)
+
+            if len(currentBatch) == 10 or index == len(dataframe) - 1:
+                    self.allBatches.append(currentBatch)
+                    currentBatch = []
+
+            # Post all batches
+            total_items = sum(len(batch) for batch in self.allBatches)
+            # print(f"Posting {len(self.allBatches)} batches ({total_items} items total)")
+
+            for cnt, batch in enumerate(self.allBatches):
+                # print(f"Posting batch {cnt + 1}/{len(self.allBatches)} for eval '{eval}'")
+                try:
+                    self.postDataStream(batch=batch, workspaceID=workspaceID)
+                    # print(f"Batch {cnt + 1} posted successfully")
+                except Exception as e:
+                    print(f"Error posting batch {cnt + 1}: {str(e)}")
+                    continue
+
+                # Small delay between batches to prevent overwhelming the server
+                time.sleep(1)
+
+            # updating the dict for row column mapping
+            self.AllProcessMapping()
+            # Calculate a reasonable timeout based on the data size
+            timeout = max(60, min(600, total_items * 10))
+            # print(f"All batches posted. Waiting up to {timeout} seconds for results...")
+
+            # Listen for results
+            self.socket.listenForResults(min_wait=20, max_wait=timeout, inactivity_timeout=30,expected_results=None)
+
+            # Get results for this evaluation
+            eval_results = self.socket.getReceivedData()
+            # print(f"Received {len(eval_results)} results for evaluation '{eval}'")
+
+            # Add these results to our overall results
+            results["Data Stream"] = self.finalResp(eval_results)
+            print(f"=======You are all set! continue your expectations 🚀======\n")
+
+            
+            # print("All evaluations completed successfully")
+
+        except Exception as e:
+            print(f"Error during evaluation: {e}")
+            raise
+        finally:
+            # Always disconnect the socket when done
+            try:
+                self.socket.disconnect()
+                # print("Socket disconnected")
+            except Exception as e:
+                print(f"Error disconnecting socket: {e}")
+
+        for streamName, records in results.items():
+            dataframe[streamName] = None
+            for item in records:
+                for compound_key, value in item.items():
+                # for compound_key, value in item['data'].items():
+
+                    rowID = compound_key.split('-')[0]
+                    # looking for the index of each rowID , in the original dataframe
+                    if rowID in rowIdMapping:
+                        index = rowIdMapping[rowID]
+                        # dataframe.at[index, evalName] = value
+                        dataframe.at[index, streamName] = value["value"]
+                        
+
+
+                    else:
+                        pass
+                        # print(f"⚠️ Warning: Could not find rowID {rowID} in mapping")
+
+        return dataframe
+    
+    
+    
+    def getId(self,workspaceID,streamName):
+        streamId=getStreamId(workspaceID,self.apiKey,streamName)
+        return streamId
+    
+    
+        
 class SafeDict(dict):
     def __missing__(self, key):
         return ""

llumo/exceptions.py

@@ -30,8 +30,10 @@ class LlumoAIError(Exception):
         return LlumoAIError(f"error: {detail}")
 
     @staticmethod
-    def InsufficientCredits():
-        return LlumoAIError("LLumo hits exhausted")
+    def InsufficientCredits(details):
+        return LlumoAIError(details)
+
+        # return LlumoAIError("LLumo hits exhausted")
 
     @staticmethod
     def InvalidPromptTemplate():
@@ -42,4 +44,8 @@ class LlumoAIError(Exception):
 
     @staticmethod
     def modelHitsExhausted(details = "Your credits for the selected model exhausted."):
-        return LlumoAIError(details)
+        return LlumoAIError(details)
+
+    # @staticmethod
+    # def dateNotFound():
+    #     return LlumoAIError("Trial end date or subscription end date not found for the given user.")

llumo/helpingFuntions.py

@@ -1,6 +1,19 @@
 import time
 import uuid
 import numpy as np
+from  datetime import datetime
+from dateutil import parser
+import requests
+import json
+import base64
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+subscriptionUrl = os.getenv("SUBSCRIPTION_URL")
+getStreamdataUrl = os.getenv("DATA_STREAM_URL")
+
+
 
 def getProcessID():
     return f"{int(time.time() * 1000)}{uuid.uuid4()}"
@@ -48,3 +61,77 @@ def costColumnMapping(costResults, allProcess):
             cost_saving.append("error occured")
 
     return compressed_prompt, compressed_prompt_output, cost, cost_saving
+
+
+def checkUserHits(workspaceID, hasSubscribed, trialEndDate, subscriptionEndDate, remainingHits, datasetLength):
+    # Get the current date (only the date part)
+    current_date = datetime.now().date()
+
+    # Parse trialEndDate if provided
+    if trialEndDate is not None:
+        try:
+            trialEndDate = parser.parse(trialEndDate).date()
+        except Exception:
+            return {"success": False, "message": "Invalid trialEndDate format"}
+
+    # Parse subscriptionEndDate if provided
+    if subscriptionEndDate is not None:
+        try:
+            subscriptionEndDate = parser.parse(subscriptionEndDate).date()
+        except Exception:
+            return {"success": False, "message": "Invalid subscriptionEndDate format"}
+
+    # If user is on a free trial
+    if not hasSubscribed and trialEndDate is not None:
+        if current_date > trialEndDate:
+            return {"success": False, "message": "Trial expired. Access denied"}
+
+        if remainingHits < datasetLength or remainingHits <= 0:
+            return {"success": False, "message": "Trial Hits Exhausted"}
+
+    else:
+        if subscriptionEndDate and current_date > subscriptionEndDate:
+            return {"success": False, "message": "Subscription expired. Access denied."}
+
+        if remainingHits <= 0 or remainingHits < datasetLength:
+            headers = {
+                "Authorization": f"Bearer {base64.b64encode(workspaceID.encode()).decode()}",
+                "Content-Type": "application/json",
+            }
+            reqBody = {"unitsToSet": 1}
+            responseBody = requests.post(url=subscriptionUrl, json=reqBody, headers=headers)
+            response = json.loads(responseBody.text)
+
+            proceed = response.get("execution", "")
+            print(proceed)
+
+            if proceed:
+                return {"success": True, "message": "Hits added and access granted."}
+
+    return {"success": True, "message": "Access granted."}
+
+def getStreamId(workspaceID: str, token, dataStreamName):
+    headers = {
+        "Authorization": f"Bearer {token}",
+        "Content-Type": "application/json",
+    }
+    reqBody = {"workspaceID": workspaceID}
+    response = requests.post(url=getStreamdataUrl, json=reqBody, headers=headers)
+
+    if response.status_code == 200:
+        responseJson = response.json()
+        data = responseJson.get("data", [])
+
+        # Find stream by name
+        matchedStream = next((stream for stream in data if stream.get("name") == dataStreamName), None)
+
+        if matchedStream:
+            
+            return matchedStream.get("dataStreamID")
+            
+        else:
+            print(f"No stream found with name: {dataStreamName}")
+            return None
+    else:
+        print("Error:", response.status_code, response.text)
+        return None

llumo-0.1.9b10.dist-info/METADATA

@@ -0,0 +1,17 @@
+Metadata-Version: 2.4
+Name: llumo
+Version: 0.1.9b10
+Summary: Python SDK for interacting with the Llumo ai API.
+Home-page: https://www.llumo.ai/
+Author: Llumo
+Author-email: product@llumo.ai
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: author-email
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+Dynamic: summary

llumo-0.1.9b10.dist-info/RECORD

@@ -0,0 +1,13 @@
+llumo/__init__.py,sha256=O04b4yW1BnOvcHzxWFddAKhtdBEhBNhLdb6xgnpHH_Q,205
+llumo/client.py,sha256=F4zabvAjLnu0N61qSw5DqerNlV5ybC2DbxaI55olldg,31916
+llumo/exceptions.py,sha256=iCj7HhtO_ckC2EaVBdXbAudNpuMDsYmmMEV5lwynZ-E,1854
+llumo/execution.py,sha256=x88wQV8eL99wNN5YtjFaAMCIfN1PdfQVlAZQb4vzgQ0,1413
+llumo/functionCalling.py,sha256=QtuTtyoz5rnfNUrNT1kzegNPOrMFjrlgxZfwTqRMdiA,7190
+llumo/helpingFuntions.py,sha256=9w1J4wMnJV1v_5yFMyxIHcvc16sEq5MZzOFBPagij5Q,4467
+llumo/models.py,sha256=YH-qAMnShmUpmKE2LQAzQdpRsaXkFSlOqMxHwU4zBUI,1560
+llumo/sockets.py,sha256=Qxxqtx3Hg07HLhA4QfcipK1ChiOYhHZBu02iA6MfYlQ,5579
+llumo-0.1.9b10.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
+llumo-0.1.9b10.dist-info/METADATA,sha256=QkiIW2Z2Lk86q5v9Reg4Pq0bNPTpWXR6NWGT0aW-Esk,429
+llumo-0.1.9b10.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+llumo-0.1.9b10.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
+llumo-0.1.9b10.dist-info/RECORD,,

{llumo-0.1.8.dist-info → llumo-0.1.9b10.dist-info}/WHEEL

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

llumo-0.1.8.dist-info/METADATA

@@ -1,26 +0,0 @@
-Metadata-Version: 2.4
-Name: llumo
-Version: 0.1.8
-Summary: Python SDK for interacting with the Llumo ai API.
-Home-page: https://www.llumo.ai/
-Author: Llumo
-Author-email: product@llumo.ai
-License: Proprietary
-Requires-Python: >=3.7
-License-File: LICENSE
-Requires-Dist: requests>=2.0.0
-Requires-Dist: websocket-client>=1.0.0
-Requires-Dist: pandas>=1.0.0
-Requires-Dist: numpy>=1.0.0
-Requires-Dist: python-socketio[client]==5.13.0
-Requires-Dist: python-dotenv==1.1.0
-Requires-Dist: openai==1.75.0
-Requires-Dist: google-generativeai==0.8.5
-Dynamic: author
-Dynamic: author-email
-Dynamic: home-page
-Dynamic: license
-Dynamic: license-file
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary

llumo-0.1.8.dist-info/RECORD

@@ -1,13 +0,0 @@
-llumo/__init__.py,sha256=O04b4yW1BnOvcHzxWFddAKhtdBEhBNhLdb6xgnpHH_Q,205
-llumo/client.py,sha256=Qc-LTgAiW4D8Q18oZlkNTDP8Csd_fPDI41zYaXkFD1M,22437
-llumo/exceptions.py,sha256=KGmztP61dkkzCTBEiRv5Xe9HrLNv1s_fYioRCG64GUU,1656
-llumo/execution.py,sha256=x88wQV8eL99wNN5YtjFaAMCIfN1PdfQVlAZQb4vzgQ0,1413
-llumo/functionCalling.py,sha256=QtuTtyoz5rnfNUrNT1kzegNPOrMFjrlgxZfwTqRMdiA,7190
-llumo/helpingFuntions.py,sha256=BWRoAAXG3Dsovc9bk-pDD2feQM_3ERXz_MwNgux0e7Q,1418
-llumo/models.py,sha256=YH-qAMnShmUpmKE2LQAzQdpRsaXkFSlOqMxHwU4zBUI,1560
-llumo/sockets.py,sha256=Qxxqtx3Hg07HLhA4QfcipK1ChiOYhHZBu02iA6MfYlQ,5579
-llumo-0.1.8.dist-info/licenses/LICENSE,sha256=tF9yAcfPV9xGT3ViWmC8hPvOo8BEk4ZICbUfcEo8Dlk,182
-llumo-0.1.8.dist-info/METADATA,sha256=nRQD4QA9Bf5OPisfsG4tjJwXN4fg5eADW1YuDxvZ-dg,695
-llumo-0.1.8.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
-llumo-0.1.8.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
-llumo-0.1.8.dist-info/RECORD,,