ragaai-catalyst 2.2.3b6__py3-none-any.whl → 2.2.4b2__py3-none-any.whl

ragaai_catalyst/synthetic_data_generation.py

@@ -517,7 +517,7 @@ class SyntheticDataGeneration:
             str: The extracted text content from the CSV, with each row joined and separated by newlines.
         """
         text = ""
-        with open(file_path, 'r', encoding='utf-8') as file:
+        with open(file_path, 'r', encoding='utf-8', errors="ignore") as file:
             csv_reader = csv.reader(file)
             for row in csv_reader:
                 text += " ".join(row) + "\n"

ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -19,6 +19,8 @@ import glob
 from logging.handlers import RotatingFileHandler
 import concurrent.futures
 from typing import Dict, Any, Optional
+import threading
+import uuid
 
 # Set up logging
 log_dir = os.path.join(tempfile.gettempdir(), "ragaai_logs")
@@ -65,19 +67,52 @@ STATUS_FAILED = "failed"
 
 # Global executor for handling uploads
 _executor = None
+_executor_lock = threading.Lock()
 # Dictionary to track futures and their associated task IDs
 _futures: Dict[str, Any] = {}
+_futures_lock = threading.Lock()
 
-def get_executor():
+
+_cleanup_lock = threading.Lock()
+_last_cleanup = 0
+CLEANUP_INTERVAL = 300  # 5 minutes
+
+# Thread-safe counter for task IDs
+_task_counter = 0
+_task_counter_lock = threading.Lock()
+
+def get_executor(max_workers=None):
     """Get or create the thread pool executor"""
     global _executor
-    if _executor is None:
-        _executor = concurrent.futures.ThreadPoolExecutor(max_workers=8, thread_name_prefix="trace_uploader")
-    return _executor
+    with _executor_lock:
+        if _executor is None:
+            # Calculate optimal worker count
+            if max_workers is None:
+                max_workers = min(32, (os.cpu_count() or 1) * 4)
+
+            logger.info(f"Creating ThreadPoolExecutor with {max_workers} workers")
+            _executor = concurrent.futures.ThreadPoolExecutor(
+                max_workers=max_workers,
+                thread_name_prefix="trace_uploader"
+            )
+            # atexit.register(shutdown)
+        return _executor
+
+
+def generate_unique_task_id():
+    """Generate a thread-safe unique task ID"""
+    global _task_counter
+
+    with _task_counter_lock:
+        _task_counter += 1
+        counter = _task_counter
+
+    unique_id = str(uuid.uuid4())[:8]  # Short UUID
+    return f"task_{int(time.time())}_{os.getpid()}_{counter}_{unique_id}"
 
 def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str, 
                   project_name: str, project_id: str, dataset_name: str, 
-                  user_details: Dict[str, Any], base_url: str, timeout=120) -> Dict[str, Any]:
+                  user_details: Dict[str, Any], base_url: str, timeout=120, fail_on_trace_error=True) -> Dict[str, Any]:
     """
     Process a single upload task
     
@@ -91,7 +126,7 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
         dataset_name: Dataset name
         user_details: User details dictionary
         base_url: Base URL for API calls
-        
+        fail_on_trace_error: If True, raise exception when trace upload fails
     Returns:
         Dict containing status and any error information
     """
@@ -176,13 +211,31 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
                     base_url=base_url,   
                     timeout=timeout
                 )
-                upload_traces.upload_agentic_traces()
-                logger.info("Agentic traces uploaded successfully")
+                upload_success = upload_traces.upload_agentic_traces()
+                if upload_success:
+                    logger.info("Agentic traces uploaded successfully")
+                else:
+                    error_msg = "Agentic traces upload failed"
+                    logger.error(error_msg)
+
+                    if fail_on_trace_error:
+                        result["status"] = STATUS_FAILED
+                        result["error"] = error_msg
+                        result["end_time"] = datetime.now().isoformat()
+                        save_task_status(result)
             except Exception as e:
                 logger.error(f"Error uploading agentic traces: {e}")
+
                 # Continue with code upload
         else:
+            error_msg = f"Trace file {filepath} not found"
             logger.warning(f"Trace file {filepath} not found, skipping traces upload")
+            if fail_on_trace_error:
+                result["status"] = STATUS_FAILED
+                result["error"] = error_msg
+                result["end_time"] = datetime.now().isoformat()
+                save_task_status(result)
+                logger.error(error_msg)
         
         # Step 4: Upload code hash
         if hash_id and zip_path and os.path.exists(zip_path):
@@ -217,6 +270,31 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
     save_task_status(result)
     return result
 
+def cleanup_completed_futures():
+    """Remove completed futures to prevent memory leaks"""
+    global _futures, _last_cleanup
+
+    current_time = time.time()
+    if current_time - _last_cleanup < CLEANUP_INTERVAL:
+        return
+
+    with _cleanup_lock:
+        if current_time - _last_cleanup < CLEANUP_INTERVAL:
+            return  # Double-check after acquiring lock
+        with _futures_lock:
+            completed_tasks = []
+            for task_id, future in _futures.items():
+                if future.done():
+                    completed_tasks.append(task_id)
+
+            for task_id in completed_tasks:
+                del _futures[task_id]
+
+            _last_cleanup = current_time
+
+            if completed_tasks:
+                logger.info(f"Cleaned up {len(completed_tasks)} completed futures")
+
 def save_task_status(task_status: Dict[str, Any]):
     """Save task status to a file"""
     task_id = task_status["task_id"]
@@ -253,38 +331,82 @@ def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, da
     filepath = os.path.abspath(filepath)
     logger.debug(f"Using absolute filepath: {filepath}")
 
-    # Generate a unique task ID
-    task_id = f"task_{int(time.time())}_{os.getpid()}_{hash(str(time.time()))}"
+    # Generate a thread-safe unique task ID
+    task_id = generate_unique_task_id()
+    logger.debug(f"Generated task ID: {task_id}")
+
+    # Function to handle synchronous processing
+    def do_sync_processing():
+        try:
+            logger.info(f"Processing task {task_id} synchronously...")
+            result = process_upload(
+                task_id=task_id,
+                filepath=filepath,
+                hash_id=hash_id,
+                zip_path=zip_path,
+                project_name=project_name,
+                project_id=project_id,
+                dataset_name=dataset_name,
+                user_details=user_details,
+                base_url=base_url,
+                timeout=timeout,
+                fail_on_trace_error=True
+            )
+            logger.info(f"Synchronous processing completed for {task_id}: {result}")
+            return task_id
+        except Exception as e:
+            logger.error(f"Error in synchronous processing: {e}")
+            return None
     
-    # Submit the task to the executor
+    # Try to get the executor
     executor = get_executor()
-    future = executor.submit(
-        process_upload,
-        task_id=task_id,
-        filepath=filepath,
-        hash_id=hash_id,
-        zip_path=zip_path,
-        project_name=project_name,
-        project_id=project_id,
-        dataset_name=dataset_name,
-        user_details=user_details,
-        base_url=base_url,
-        timeout=timeout
-    )
-    
-    # Store the future for later status checks
-    _futures[task_id] = future
-    
-    # Create initial status
-    initial_status = {
-        "task_id": task_id,
-        "status": STATUS_PENDING,
-        "error": None,
-        "start_time": datetime.now().isoformat()
-    }
-    save_task_status(initial_status)
-    
-    return task_id
+    if executor is None:
+        logger.warning("Executor is None or shutdown in progress, processing synchronously")
+        return do_sync_processing()
+    # Cleanup completed futures periodically
+    # cleanup_completed_futures()
+    # Try to submit the task to the executor
+    try:
+        # Cleanup completed futures periodically
+        future = executor.submit(
+            process_upload,
+            task_id=task_id,
+            filepath=filepath,
+            hash_id=hash_id,
+            zip_path=zip_path,
+            project_name=project_name,
+            project_id=project_id,
+            dataset_name=dataset_name,
+            user_details=user_details,
+            base_url=base_url,
+            timeout=timeout,
+            fail_on_trace_error=True
+        )
+        
+        # Store the future for later status checks
+        with _futures_lock:
+            _futures[task_id] = future
+        
+        # Create initial status
+        initial_status = {
+            "task_id": task_id,
+            "status": STATUS_PENDING,
+            "error": None,
+            "start_time": datetime.now().isoformat()
+        }
+        save_task_status(initial_status)
+        
+        return task_id
+    except RuntimeError as e:
+        if "cannot schedule new futures after shutdown" in str(e):
+            logger.warning(f"Executor already shut down, falling back to synchronous processing: {e}")
+            return do_sync_processing()
+        else:
+            logger.error(f"Error submitting task: {e}")
+            return None
+    except Exception as e:
+        logger.error(f"Error submitting task: {e}")
+        return None
 
 def get_task_status(task_id):
     """
@@ -299,7 +421,8 @@ def get_task_status(task_id):
     logger.debug(f"Getting status for task {task_id}")
     
     # Check if we have a future for this task
-    future = _futures.get(task_id)
+    with _futures_lock:
+        future = _futures.get(task_id)
     
     # If we have a future, check its status
     if future:
@@ -328,13 +451,104 @@ def get_task_status(task_id):
     
     return {"status": "unknown", "error": "Task not found"}
 
-def shutdown():
-    """Shutdown the executor"""
-    global _executor
-    if _executor:
-        logger.info("Shutting down executor")
-        _executor.shutdown(wait=True)
-        _executor = None
+
+def get_upload_queue_status():
+    """Get detailed status of upload queue"""
+    logger.info("Reached get queue status")
+    # with _executor_lock:
+    executor = get_executor()
+
+    if executor is None:
+        return {
+            "total_submitted": 0,
+            "pending_uploads": 0,
+            "completed_uploads": 0,
+            "failed_uploads": 0,
+            "thread_pool_queue_size": 0,
+            "active_workers": 0,
+            "max_workers": 0
+        }
+    # with _futures_lock:
+    pending_count = len([f for f in _futures.values() if not f.done()])
+    completed_count = len([f for f in _futures.values() if f.done() and not f.exception()])
+    failed_count = len([f for f in _futures.values() if f.done() and f.exception()])
+
+    # Try to get thread pool queue size (may not be available in all Python versions)
+    queue_size = 0
+    try:
+        if hasattr(executor, '_work_queue'):
+            queue_size = executor._work_queue.qsize()
+    except:
+        pass
+
+    return {
+        "total_submitted": len(_futures),
+        "pending_uploads": pending_count,
+        "completed_uploads": completed_count,
+        "failed_uploads": failed_count,
+        "thread_pool_queue_size": queue_size,
+        "active_workers": getattr(executor, '_threads', set()).__len__() if executor else 0,
+        "max_workers": executor._max_workers if executor else 0
+    }
+
+
+def shutdown(timeout=120):
+    """Enhanced shutdown with manual timeout and progress reporting"""
+    logger.debug("Reached shutdown of executor")
+    global _executor, _futures
+    with _executor_lock:
+        if _executor is None:
+            logger.debug("Executor is none in shutdown")
+            return
+
+    # Log current state
+    status = get_upload_queue_status()
+    logger.debug(f"Queue status: {status}")
+    logger.debug(f"Shutting down uploader. Pending uploads: {status['pending_uploads']}")
+
+    if status['pending_uploads'] > 0:
+        logger.debug(f"Waiting up to {timeout}s for {status['pending_uploads']} uploads to complete...")
+
+        start_time = time.time()
+        last_report = start_time
+
+        while time.time() - start_time < timeout:
+            # Check if all futures are done
+            with _futures_lock:
+                pending_futures = [f for f in _futures.values() if not f.done()]
+
+                if not pending_futures:
+                    logger.info("All uploads completed successfully")
+                    break
+
+                # Report progress every 10 seconds
+                current_time = time.time()
+                if current_time - last_report >= 10:
+                    elapsed = current_time - start_time
+                    remaining = timeout - elapsed
+                    logger.info(f"Still waiting for {len(pending_futures)} uploads to complete. "
+                                f"Time remaining: {remaining:.1f}s")
+                    last_report = current_time
+
+                # Sleep briefly to avoid busy waiting
+                time.sleep(0.5)
+        else:
+            # Timeout reached
+            logger.info("Executor timeout reached")
+            with _futures_lock:
+                pending_futures = [f for f in _futures.values() if not f.done()]
+                logger.debug(f"Shutdown timeout reached. {len(pending_futures)} uploads still pending.")
+    else:
+        logger.info(f"No pending uploads")
+
+    # Shutdown the executor
+    try:
+        _executor.shutdown(wait=False)  # Don't wait here since we already waited above
+        logger.info("Executor shutdown initiated")
+    except Exception as e:
+        logger.error(f"Error during executor shutdown: {e}")
+
+    _executor = None
 
 # Register shutdown handler
 atexit.register(shutdown)

ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py

@@ -144,7 +144,7 @@ class UploadAgenticTraces:
                 payload = f.read().replace("\n", "").replace("\r", "").encode()
         except Exception as e:
             print(f"Error while reading file: {e}")
-            return None
+            return False
         try:
             start_time = time.time()
             response = requests.request(
@@ -156,9 +156,10 @@ class UploadAgenticTraces:
             )
             if response.status_code != 200 or response.status_code != 201:
                 return response, response.status_code
+            return True
         except requests.exceptions.RequestException as e:
             print(f"Error while uploading to presigned url: {e}")
-            return None
+            return False
 
     def insert_traces(self, presignedUrl):
         headers = {
@@ -185,7 +186,7 @@ class UploadAgenticTraces:
             )
             if response.status_code != 200:
                 print(f"Error inserting traces: {response.json()['message']}")
-                return None
+                return False
             elif response.status_code == 401:
                 logger.warning("Received 401 error. Attempting to refresh token.")
                 token = RagaAICatalyst.get_token(force_refresh=True)
@@ -207,10 +208,12 @@ class UploadAgenticTraces:
                 )
                 if response.status_code != 200:
                     print(f"Error inserting traces: {response.json()['message']}")
-                    return None
+                    return False
                 else:
                     print("Error while inserting traces")
-                    return None
+                    return False
+            else:
+                return True
         except requests.exceptions.RequestException as e:
             print(f"Error while inserting traces: {e}")
             return None
@@ -247,10 +250,35 @@ class UploadAgenticTraces:
 
     def upload_agentic_traces(self):
         try:
-            presignedUrl = self._get_presigned_url()
-            if presignedUrl is None:
-                return
-            self._put_presigned_url(presignedUrl, self.json_file_path)
-            self.insert_traces(presignedUrl)
+            presigned_url = self._get_presigned_url()
+            if presigned_url is None:
+                print("Warning: Failed to obtain presigned URL")
+                return False
+
+            # Upload the file using the presigned URL
+            upload_result = self._put_presigned_url(presigned_url, self.json_file_path)
+            if not upload_result:
+                print("Error: Failed to upload file to presigned URL")
+                return False
+            elif isinstance(upload_result, tuple):
+                response, status_code = upload_result
+                if status_code not in [200, 201]:
+                    print(
+                        f"Error: Upload failed with status code {status_code}: {response.text if hasattr(response, 'text') else 'Unknown error'}")
+                    return False
+            # Insert trace records
+            insert_success = self.insert_traces(presigned_url)
+            if not insert_success:
+                print("Error: Failed to insert trace records")
+                return False
+
+            print("Successfully uploaded agentic traces")
+            return True
+        except FileNotFoundError:
+            print(f"Error: Trace file not found at {self.json_file_path}")
+            return False
+        except ConnectionError as e:
+            print(f"Error: Network connection failed while uploading traces: {e}")
+            return False
         except Exception as e:
             print(f"Error while uploading agentic traces: {e}")

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -76,6 +76,7 @@ class RAGATraceExporter(SpanExporter):
 
     def shutdown(self):
         # Process any remaining traces during shutdown
+        logger.debug("Reached shutdown of exporter")
         for trace_id, spans in self.trace_spans.items():
             self.process_complete_trace(spans, trace_id)
         self.trace_spans.clear()

{ragaai_catalyst-2.2.3b6.dist-info → ragaai_catalyst-2.2.4b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.2.3b6
+Version: 2.2.4b2
 Summary: RAGA AI CATALYST
 Author-email: Kiran Scaria <kiran.scaria@raga.ai>, Kedar Gaikwad <kedar.gaikwad@raga.ai>, Dushyant Mahajan <dushyant.mahajan@raga.ai>, Siddhartha Kosti <siddhartha.kosti@raga.ai>, Ritika Goel <ritika.goel@raga.ai>, Vijay Chaurasia <vijay.chaurasia@raga.ai>, Tushar Kumar <tushar.kumar@raga.ai>, Rishabh Pandey <rishabh.pandey@raga.ai>, Jyotsana C G <jyotsana@raga.ai>
 Requires-Python: <=3.13.2,>=3.10

{ragaai_catalyst-2.2.3b6.dist-info → ragaai_catalyst-2.2.4b2.dist-info}/RECORD

@@ -10,7 +10,7 @@ ragaai_catalyst/prompt_manager.py,sha256=W8ypramzOprrJ7-22d5vkBXIuIQ8v9XAzKDGxKs
 ragaai_catalyst/proxy_call.py,sha256=CHxldeceZUaLU-to_hs_Kf1z_b2vHMssLS_cOBedu78,5499
 ragaai_catalyst/ragaai_catalyst.py,sha256=ZlcpOgJA9lVRi51YFy4dVfsxU0I79LJu0MnVI5BIL-c,25201
 ragaai_catalyst/redteaming_old.py,sha256=W2d89Ok8W-C8g7TBM3fDIFLof3q9FuYSr0jcryH2XQo,7097
-ragaai_catalyst/synthetic_data_generation.py,sha256=7lIWa3nwgW2-FlJrDaGxTN6OE4-dbbhLtKNOBQufhho,37952
+ragaai_catalyst/synthetic_data_generation.py,sha256=AumjIzKk-Uvn7RQGatpx7TPvlI4NjU-rUiVFockoGNg,37969
 ragaai_catalyst/utils.py,sha256=TlhEFwLyRU690HvANbyoRycR3nQ67lxVUQoUOfTPYQ0,3772
 ragaai_catalyst/redteaming/__init__.py,sha256=TJdvZpaZGFsg9qKONdjTosSVLZGadYFpHG6KE0xapKU,155
 ragaai_catalyst/redteaming/evaluator.py,sha256=C50SAc3RsR7PZnz-VQ7wQfDpiVEb7T3W3KV4Lj0tWYE,4599
@@ -54,8 +54,8 @@ ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py,sha256=m8CxYkl
 ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=xxrliKPfdfbIZRZqMnUewsaTD8_Hv0dbuoBivNZGD4U,21674
 ragaai_catalyst/tracers/agentic_tracing/tracers/user_interaction_tracer.py,sha256=bhSUhNQCuJXKjgJAXhjKEYjnHMpYN90FSZdR84fNIKU,4614
 ragaai_catalyst/tracers/agentic_tracing/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=FqHjvFdq5Pqp8iZcLTwXaxnMmm8ATec3fLdDuzLITFs,13019
-ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=qcii8NMZGJvmv19AokjCH2egGIsALLWK9JqHtgkFB_0,10447
+ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py,sha256=iMUMFR9XVipCBunpv8_No8bCoP3lqG47M5dg-ugibWo,21006
+ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=t3spo5w7TyfR0Zeqm1h5Z-bJ-BlZ3EPGTvRdK5lpFpE,11705
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py,sha256=2mxdi7k_SoDqQUFo1oQ__28CpmSIvVugYcbuRltUK9Q,9920
 ragaai_catalyst/tracers/agentic_tracing/upload/upload_local_metric.py,sha256=m1O8lKpxKwtHofXLW3fTHX5yfqDW5GxoveARlg5cTw4,2571
 ragaai_catalyst/tracers/agentic_tracing/utils/__init__.py,sha256=XdB3X_ufe4RVvGorxSqAiB9dYv4UD7Hvvuw3bsDUppY,60
@@ -76,7 +76,7 @@ ragaai_catalyst/tracers/exporters/__init__.py,sha256=wQbaqyeIjVZxYprHCKZ9BeiqxeX
 ragaai_catalyst/tracers/exporters/dynamic_trace_exporter.py,sha256=Rm-QaLv1qMAKpHKcFOcK_HWaKHwFBoUH45_4QYipE-g,6843
 ragaai_catalyst/tracers/exporters/file_span_exporter.py,sha256=NZsD3rShUiC3rO9y3Y2vqEtS3MO51FXZy0p3q9cdDNY,6403
 ragaai_catalyst/tracers/exporters/raga_exporter.py,sha256=l-RfysTIXYxtvYkVlJbRvg-AzJbT4Fdb-YiZh0mfuDs,17868
-ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py,sha256=OnvgZM-fzF8nFDdqD0u9wVSU4KfwPklhsdz0d7hVLX4,8926
+ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py,sha256=VLvlWFRFPhE32WrF-_J_vCczduz13WAcOW8MKDgDYJc,8979
 ragaai_catalyst/tracers/instrumentators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ragaai_catalyst/tracers/utils/__init__.py,sha256=KeMaZtYaTojilpLv65qH08QmpYclfpacDA0U3wg6Ybw,64
 ragaai_catalyst/tracers/utils/convert_langchain_callbacks_output.py,sha256=SehrD7q8ytAiUYoWr406b4mWs3Lk0Rcy6Ekkihh22TI,1703
@@ -88,8 +88,8 @@ ragaai_catalyst/tracers/utils/rag_extraction_logic_final.py,sha256=3ygkRT__lLDRf
 ragaai_catalyst/tracers/utils/rag_trace_json_converter.py,sha256=54IEZO-YRjUAahV5nw8KClXqTF1LhfDry_TsZ4KGow4,20467
 ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=U9GFVDCWRQvmBSMTDIZoMerJCnH8Gijw95r2oQbuFdQ,11560
 ragaai_catalyst/tracers/utils/utils.py,sha256=o-p9n2ZuophdrV0wrixu-BqRHCkovup_klc3mS8mU8g,2374
-ragaai_catalyst-2.2.3b6.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.2.3b6.dist-info/METADATA,sha256=6HW0Xxvqnvfy1zMFrrpVYxfsFfl-iKQl4N68Fd6dMAI,17679
-ragaai_catalyst-2.2.3b6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ragaai_catalyst-2.2.3b6.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.2.3b6.dist-info/RECORD,,
+ragaai_catalyst-2.2.4b2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.2.4b2.dist-info/METADATA,sha256=Bcb8Sy5bnItaKkXpEJUlh0gRUe1sq2HIrW3XUkglWcU,17679
+ragaai_catalyst-2.2.4b2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ragaai_catalyst-2.2.4b2.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.2.4b2.dist-info/RECORD,,