llumo 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

llumo/client.py

@@ -149,168 +149,149 @@ class LlumoClient:
 
         return uniqueResults
 
-    def evaluate(self, dataframe, evals=["Response Completeness"], prompt_template="",outputColName = "output"):
-
+    def evaluate(self, dataframe, eval ="Response Completeness", prompt_template="", outputColName="output"):
 
         results = {}
         try:
-            # Connect to socket first
-            # print("Connecting to socket server...")
-            socketID = self.socket.connect(timeout=30)
-            # print(f"Connected with socket ID: {socketID}")
+            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.")
 
-            # Store the mapping of row IDs to dataframe indices
             rowIdMapping = {}
 
-            # Process each evaluation
-            for eval in evals:
-                print(f"\n======= Running evaluation for: {eval} =======")
 
-                try:
-                    # print(f"Validating API key for {eval}...")
-                    self.validateApiKey(evalName=eval)
-                    # 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]}...")
-                        pass
-                    raise
-
-                if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
-                    raise LlumoAIError.InsufficientCredits()
-
-                evalDefinition = self.evalDefinition[eval]
-                model = "GPT_4"
-                provider = "OPENAI"
-                evalType = "LLM"
-                workspaceID = self.workspaceID
-
-                # Prepare all batches before sending
-                # print("Preparing batches...")
-                self.allBatches = []
-                currentBatch = []
-
-                for index, row in dataframe.iterrows():
-                    tools = [row["tools"]] if "tools" in dataframe.columns else []
-                    groundTruth = row["groundTruth"] if "groundTruth" in dataframe.columns else ""
-                    messageHistory = [row["messageHistory"]] if "messageHistory" in dataframe.columns else []
-                    promptTemplate = prompt_template
-
-                    keys = re.findall(r"{{(.*?)}}", promptTemplate)
-
-                    # raise error if the prompt template is not in expected format
-                    if not all([ky in dataframe.columns for ky in keys]):
-                        raise LlumoAIError.InvalidPromptTemplate()
-
-                    inputDict = {key: row[key] for key in keys if key in row}
-
-
-                    output = row[outputColName] if outputColName in dataframe.columns else ""
-
-                    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
-
-                    templateData = {
-                        "processID": getProcessID(),
-                        "socketID": socketID,
-                        "source": "SDK",
-                        "processData": {
-                            "executionDependency": {
-                                "query": "",
-                                "context": "",
-                                "output": output,
-                                "tools": tools,
-                                "groundTruth": groundTruth,
-                                "messageHistory": messageHistory,
-                            },
-                            "definition": evalDefinition,
-                            "model": model,
-                            "provider": provider,
-                            "analytics": eval,
+            print(f"\n======= Running evaluation for: {eval} =======")
+
+            try:
+                self.validateApiKey(evalName=eval)
+            except Exception as e:
+                if hasattr(e, "response") and getattr(e, "response", None) is not None:
+                    pass
+                raise
+
+            if self.hitsAvailable == 0 or len(dataframe) > self.hitsAvailable:
+                raise LlumoAIError.InsufficientCredits()
+
+            evalDefinition = self.evalDefinition[eval]
+            model = "GPT_4"
+            provider = "OPENAI"
+            evalType = "LLM"
+            workspaceID = self.workspaceID
+
+            self.allBatches = []
+            currentBatch = []
+
+            for index, row in dataframe.iterrows():
+                tools = [row["tools"]] if "tools" in dataframe.columns else []
+                groundTruth = row["groundTruth"] if "groundTruth" in dataframe.columns else ""
+                messageHistory = [row["messageHistory"]] if "messageHistory" in dataframe.columns else []
+                promptTemplate = prompt_template
+
+                keys = re.findall(r"{{(.*?)}}", promptTemplate)
+
+                if not all([ky in dataframe.columns for ky in keys]):
+                    raise LlumoAIError.InvalidPromptTemplate()
+
+                inputDict = {key: row[key] for key in keys if key in row}
+                output = row[outputColName] if outputColName in dataframe.columns else ""
+
+                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
+
+                templateData = {
+                    "processID": getProcessID(),
+                    "socketID": socketID,
+                    "source": "SDK",
+                    "processData": {
+                        "executionDependency": {
+                            "query": "",
+                            "context": "",
+                            "output": output,
+                            "tools": tools,
+                            "groundTruth": groundTruth,
+                            "messageHistory": messageHistory,
                         },
-                        "workspaceID": workspaceID,
-                        "type": "EVAL",
-                        "evalType": evalType,
-                        "kpi": eval,
-                        "columnID": columnID,
-                        "rowID": rowID,
-                        "playgroundID": activePlayground,
-                        "processType": "EVAL",
-                    }
+                        "definition": evalDefinition,
+                        "model": model,
+                        "provider": provider,
+                        "analytics": eval,
+                    },
+                    "workspaceID": workspaceID,
+                    "type": "EVAL",
+                    "evalType": evalType,
+                    "kpi": eval,
+                    "columnID": columnID,
+                    "rowID": rowID,
+                    "playgroundID": activePlayground,
+                    "processType": "EVAL",
+                }
 
-                    query = ""
-                    context = ""
-                    for key, value in inputDict.items():
-                        if isinstance(value, str):
-                            length = len(value.split()) * 1.5
-                            if length > 50:
-                                context += f" {key}: {value}, "
-                            else:
-                                if promptTemplate:
-                                    tempObj = {key: value}
-                                    promptTemplate = getInputPopulatedPrompt(promptTemplate, tempObj)
-                                else:
-                                    query += f" {key}: {value}, "
-
-                    if not context.strip():
-                        for key, value in inputDict.items():
+                query = ""
+                context = ""
+                for key, value in inputDict.items():
+                    if isinstance(value, str):
+                        length = len(value.split()) * 1.5
+                        if length > 50:
                             context += f" {key}: {value}, "
+                        else:
+                            if promptTemplate:
+                                tempObj = {key: value}
+                                promptTemplate = getInputPopulatedPrompt(promptTemplate, tempObj)
+                            else:
+                                query += f" {key}: {value}, "
 
-                    templateData["processData"]["executionDependency"]["context"] = context.strip()
-                    templateData["processData"]["executionDependency"]["query"] = query.strip()
-
-                    if promptTemplate and not query.strip():
-                        templateData["processData"]["executionDependency"]["query"] = promptTemplate
+                if not context.strip():
+                    for key, value in inputDict.items():
+                        context += f" {key}: {value}, "
 
-                    currentBatch.append(templateData)
+                templateData["processData"]["executionDependency"]["context"] = context.strip()
+                templateData["processData"]["executionDependency"]["query"] = query.strip()
 
-                    if len(currentBatch) == 10 or index == len(dataframe) - 1:
-                        self.allBatches.append(currentBatch)
-                        currentBatch = []
+                if promptTemplate and not query.strip():
+                    templateData["processData"]["executionDependency"]["query"] = promptTemplate
 
-                totalItems  = sum(len(batch) for batch in self.allBatches)
-                # print(f"Posting {len(self.allBatches)} batches ({totalItems } items total)")
+                currentBatch.append(templateData)
 
-                for cnt, batch in enumerate(self.allBatches):
-                    # print(f"Posting batch {cnt + 1}/{len(self.allBatches)} for eval '{eval}'")
-                    try:
-                        self.postBatch(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
+                if len(currentBatch) == 10 or index == len(dataframe) - 1:
+                    self.allBatches.append(currentBatch)
+                    currentBatch = []
 
-                    time.sleep(1)
+            totalItems = sum(len(batch) for batch in self.allBatches)
 
-                timeout = max(60, min(600, totalItems  * 10))
-                # print(f"All batches posted. Waiting up to {timeout} seconds for results...")
+            for cnt, batch in enumerate(self.allBatches):
+                try:
+                    self.postBatch(batch=batch, workspaceID=workspaceID)
+                    # print("Betch Posted with item len: ", len(batch))
+                except Exception as e:
+                    continue
 
-                self.socket.listenForResults(
-                    min_wait=40, max_wait=timeout, inactivity_timeout=40
-                )
+                time.sleep(1)
 
-                eval_results = self.socket.getReceivedData()
-                # print(f"Received {len(eval_results)} results for evaluation '{eval}'")
+            timeout = max(50, min(600, totalItems * 10))
 
-                results[eval] = self.finalResp(eval_results)
-                # print(f"======= Completed evaluation: {eval} =======\n")
+            self.socket.listenForResults(
+                min_wait=40, max_wait=timeout, inactivity_timeout=150, expected_results=totalItems
+            )
 
-            # print("All evaluations completed successfully")
+            eval_results = self.socket.getReceivedData()
+            results[eval] = self.finalResp(eval_results)
 
         except Exception as e:
-            # print(f"Error during evaluation: {e}")
             raise
         finally:
             try:
                 self.socket.disconnect()
-                # print("Socket disconnected")
             except Exception as e:
-                # print(f"Error disconnecting socket: {e}")
                 pass
 
         for evalName, records in results.items():
@@ -322,17 +303,28 @@ class LlumoClient:
                         index = rowIdMapping[rowID]
                         dataframe.at[index, evalName] = value
                     else:
-                        print(f"Warning: Could not find rowID {rowID} in mapping")
                         pass
+                        # print(f"⚠️ Warning: Could not find rowID {rowID} in mapping")
 
         return dataframe
 
     def evaluateCompressor(self, dataframe, prompt_template):
         results = []
+        
         try:
             # Connect to socket first
             # print("Connecting to socket server...")
-            socketID = self.socket.connect(timeout=30)
+            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}")
 
             try:
@@ -443,7 +435,7 @@ class LlumoClient:
                 if promptTemplate and not query.strip():
                     templateData["processData"]["rowData"]["query"]["value"] = promptTemplate
 
-                print(templateData)
+                # print(templateData)
                 currentBatch.append(templateData)
 
             if len(currentBatch) == 10 or index == len(dataframe) - 1:
@@ -452,13 +444,13 @@ class LlumoClient:
 
             # Post all batches
             total_items = sum(len(batch) for batch in self.allBatches)
-            print(f"Posting {len(self.allBatches)} batches ({total_items} items total)")
+            # 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}'")
+                # print(f"Posting batch {cnt + 1}/{len(self.allBatches)} for eval '{eval}'")
                 try:
                     self.postBatch(batch=batch, workspaceID=workspaceID)
-                    print(f"Batch {cnt + 1} posted successfully")
+                    # print(f"Batch {cnt + 1} posted successfully")
                 except Exception as e:
                     print(f"Error posting batch {cnt + 1}: {str(e)}")
                     continue
@@ -473,7 +465,7 @@ class LlumoClient:
             # 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)
+            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()
@@ -504,7 +496,7 @@ class LlumoClient:
         return dataframe
 
 
-    def run_sweep(self,templates: List[str], dataset: Dict[str, List[str]], model_aliases: List[AVAILABLEMODELS], apiKey: str, evals = ["Response Correctness"]) -> pd.DataFrame:
+    def run_sweep(self,templates: List[str], dataset: Dict[str, List[str]], model_aliases: List[AVAILABLEMODELS], apiKey: str, eval  = ["Response Correctness"],toEvaluate:bool =False ) -> pd.DataFrame:
         executor = ModelExecutor(apiKey)
 
         keys = list(dataset.keys())
@@ -538,10 +530,12 @@ class LlumoClient:
                     
                     results.append(row)
         df=pd.DataFrame(results)
+        if toEvaluate:
+        
+            res = self.evaluate(df,eval  =eval ,prompt_template=str(templates[0]))
+            return res
         
-        print(str(templates[0]))
-        res = self.evaluate(df,evals =evals,prompt_template=str(templates[0]))
-        return res
+        return df
 
     def evaluateAgents(self, dataframe, model, agents, model_api_key=None,
                        prompt_template="Give answer for the given query: {{query}}"):
@@ -550,13 +544,15 @@ class LlumoClient:
 
         # Run unified agent execution
         toolResponseDf = LlumoAgentExecutor.run(dataframe, agents, model=model, model_api_key=model_api_key)
-
-        # Perform evaluation
-        res = self.evaluate(
-            toolResponseDf,
-            evals=["Tool Reliability", "Stepwise Progression", "Tool Selection Accuracy", "Final Task Alignment"],
-            prompt_template=prompt_template
-        )
+        evals = ["Tool Reliability", "Stepwise Progression", "Tool Selection Accuracy", "Final Task Alignment"]
+
+        for eval in evals:
+            # Perform evaluation
+            toolResponseDf = self.evaluate(
+                toolResponseDf,
+                eval = eval,
+                prompt_template=prompt_template
+            )
         return toolResponseDf
 
 

llumo/functionCalling.py

@@ -176,8 +176,9 @@ class LlumoAgentExecutor:
                     messageHistories.append(str(messages))
 
                 except Exception as e:
-                    results.append(f"Error during processing: {e}")
-                    messageHistories.append("Error in conversation")
+                    # results.append(f"Error during processing: {e}")
+                    # messageHistories.append("Error in conversation")
+                    raise LlumoAIError.modelHitsExhausted()
 
             df["output"] = results
             df["messageHistory"] = messageHistories

llumo/sockets.py

@@ -13,13 +13,14 @@ class LlumoSocketClient:
         self._lock = threading.Lock()
         self._connected = False
         self.server_socket_id = None  # Store the server-assigned socket ID
+        self._expected_results = None  # NEW
 
         # Initialize client
         self.sio = socketio.Client(
             # logger=True,
             # engineio_logger=True,
             reconnection=True,
-            reconnection_attempts=5,
+            reconnection_attempts=10,
             reconnection_delay=1,
         )
 
@@ -47,6 +48,11 @@ class LlumoSocketClient:
                 self._received_data.append(data)
                 self._last_update_time = time.time()
 
+                # ✅ Stop if all expected results are received
+                if self._expected_results and len(self._received_data) >= self._expected_results:
+                    # print("✅ All expected results received.")
+                    self._listening_done.set()
+
         @self.sio.on("disconnect")
         def on_disconnect():
             # print("Socket disconnected")
@@ -65,38 +71,40 @@ class LlumoSocketClient:
         self._connection_established.clear()
         self._listening_done.clear()
         self.server_socket_id = None
+        self._connected = False
 
         try:
-            # print("Attempting direct WebSocket connection...")
-            # Connect with websocket transport
+            # print("[DEBUG] Connecting to socket...")
             self.sio.connect(self.socket_url, transports=["websocket"], wait=True)
 
-            # print(f"Engine.IO connection established with SID: {self.sio.sid}")
-            # print( "Waiting for server to acknowledge connection with connection-established event...")
+            # Wait for socket connection
+            start = time.time()
+            while not self.sio.connected:
+                if time.time() - start > timeout:
+                    raise RuntimeError("Timed out waiting for low-level socket connection.")
+                time.sleep(0.1)
+            # print("[DEBUG] SocketIO low-level connection established.")
 
-            # Wait for the connection-established event
+            # Wait for server "connection-established" event
             if not self._connection_established.wait(timeout):
-                raise RuntimeError("Timed out waiting for connection-established event")
+                raise RuntimeError("Timed out waiting for connection-established event.")
 
+            self._connected = True
             self._last_update_time = time.time()
-            # print(f"Connection fully established. Server socket ID: {self.server_socket_id}")
+            # print(f"[DEBUG] Full connection established. Connected: {self._connected}")
 
-            # Return the server-assigned socket ID if available, otherwise fall back to the client's SID
             return self.server_socket_id or self.sio.sid
+
         except Exception as e:
+            # print(f"[DEBUG] Connection failed with error: {e}")
             self._connected = False
             raise RuntimeError(f"WebSocket connection failed: {e}")
 
-    def listenForResults(self, min_wait=30, max_wait=300, inactivity_timeout=50):
-        """
-        Listen for results with improved timeout handling:
-        - min_wait: Minimum time to wait even if no data is received
-        - max_wait: Maximum total time to wait for results
-        - inactivity_timeout: Time to wait after last data received
-        """
+    def listenForResults(self, min_wait=30, max_wait=300, inactivity_timeout=50, expected_results=None):
         if not self._connected:
             raise RuntimeError("WebSocket is not connected. Call connect() first.")
 
+        self._expected_results = expected_results  # NEW
         start_time = time.time()
         self._last_update_time = time.time()
 
@@ -106,31 +114,25 @@ class LlumoSocketClient:
                 time_since_last_update = current_time - self._last_update_time
                 total_elapsed = current_time - start_time
 
-                # Always wait for minimum time
                 if total_elapsed < min_wait:
                     time.sleep(0.5)
                     continue
 
-                # Stop if maximum time exceeded
                 if total_elapsed > max_wait:
-                    # print(f"⚠️ Maximum wait time of {max_wait}s reached, stopping listener.")
+                    # print(f"⚠️ Max wait time {max_wait}s exceeded.")
                     self._listening_done.set()
                     break
 
-                # Stop if no activity for inactivity_timeout
                 if time_since_last_update > inactivity_timeout:
-                    # print(f"⚠️ No data received for {inactivity_timeout}s, stopping listener.")
+                    # print(f"⚠️ Inactivity timeout {inactivity_timeout}s exceeded.")
                     self._listening_done.set()
                     break
 
-                # Check every second
                 time.sleep(1)
 
         timeout_thread = threading.Thread(target=timeout_watcher, daemon=True)
         timeout_thread.start()
-        # print("Started listening for WebSocket events...")
         self._listening_done.wait()
-        # print(f"Finished listening. Received {len(self._received_data)} data updates.")
 
     def getReceivedData(self):
         with self._lock:

{llumo-0.1.7.dist-info → llumo-0.1.9.dist-info}/METADATA

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

llumo-0.1.9.dist-info/RECORD

@@ -0,0 +1,14 @@
+llumo/.env,sha256=Vx5FkuywpYHXH2N8epJ7PlNOPiwx9UP9DUz4vWd0urs,373
+llumo/__init__.py,sha256=Ro08YEqv03qSyn54Gj8x2LUSLSZeXBQjvuODmMpqjHA,212
+llumo/client.py,sha256=9QtL8xLH0doqkJIQqhNIaR3Mlma2hkiQsylFLfaboKs,22998
+llumo/exceptions.py,sha256=bmYQYdTz2ooM0CYs3M4iHYxQrVmc46dNey_fCkiaUxo,1700
+llumo/execution.py,sha256=jSkyI2l6bowum82RDI60Tkmoe2bVnrvkJnqr8mNWjBE,1451
+llumo/functionCalling.py,sha256=_qVC987oR7nWIFmRSKDkysMgXC7tJycN6nUUniBusAc,7380
+llumo/helpingFuntions.py,sha256=_eGra7Ci79eI2e37hSIq3CMN2bgdQUTv55PydITs5NI,1468
+llumo/models.py,sha256=WBtnu7ckOy9TGRiwswz04xOGYF6EslTUOxHUz4QWzUA,1602
+llumo/sockets.py,sha256=uehnOHKqZYKek4XN5ya348OmdED-hGTXRcO8onL1XUM,5727
+llumo-0.1.9.dist-info/licenses/LICENSE,sha256=vMiqSi3KpDHq3RFxKiqdh10ZUF3PjE3nnntANU-HEu4,186
+llumo-0.1.9.dist-info/METADATA,sha256=NpdYEwl-E-gmFVSLtfEyxafcZF8ykErKEvVha2VDIdY,721
+llumo-0.1.9.dist-info/WHEEL,sha256=wXxTzcEDnjrTwFYjLPcsW_7_XihufBwmpiBeiXNBGEA,91
+llumo-0.1.9.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
+llumo-0.1.9.dist-info/RECORD,,

{llumo-0.1.7.dist-info → llumo-0.1.9.dist-info}/WHEEL

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

llumo-0.1.7.dist-info/RECORD

@@ -1,14 +0,0 @@
-llumo/.env,sha256=Vx5FkuywpYHXH2N8epJ7PlNOPiwx9UP9DUz4vWd0urs,373
-llumo/__init__.py,sha256=Ro08YEqv03qSyn54Gj8x2LUSLSZeXBQjvuODmMpqjHA,212
-llumo/client.py,sha256=hrKH97PZ6i3KMfT7a6g3KzN_pzvpN8W5oMWMn2gO4tI,23986
-llumo/exceptions.py,sha256=bmYQYdTz2ooM0CYs3M4iHYxQrVmc46dNey_fCkiaUxo,1700
-llumo/execution.py,sha256=jSkyI2l6bowum82RDI60Tkmoe2bVnrvkJnqr8mNWjBE,1451
-llumo/functionCalling.py,sha256=JwCxK_TJcFZMPP7ujqsoYfrX45XLxQfGqmyOdlwAtcM,7315
-llumo/helpingFuntions.py,sha256=_eGra7Ci79eI2e37hSIq3CMN2bgdQUTv55PydITs5NI,1468
-llumo/models.py,sha256=WBtnu7ckOy9TGRiwswz04xOGYF6EslTUOxHUz4QWzUA,1602
-llumo/sockets.py,sha256=rxeUHaxwqg1vSlplohS-aLycbW125ocqk04RiV20Ldg,5835
-llumo-0.1.7.dist-info/licenses/LICENSE,sha256=vMiqSi3KpDHq3RFxKiqdh10ZUF3PjE3nnntANU-HEu4,186
-llumo-0.1.7.dist-info/METADATA,sha256=jwC_sLeRrvmw-uJv_xbVbn3AbeUBYWB7RaPzQdE3850,721
-llumo-0.1.7.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-llumo-0.1.7.dist-info/top_level.txt,sha256=d5zUTMI99llPtLRB8rtSrqELm_bOqX-bNC5IcwlDk88,6
-llumo-0.1.7.dist-info/RECORD,,