ragaai-catalyst 2.2.4.2b1__tar.gz → 2.2.5__tar.gz

{ragaai_catalyst-2.2.4.2b1/ragaai_catalyst.egg-info → ragaai_catalyst-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.2.4.2b1
+Version: 2.2.5
 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
@@ -41,6 +41,7 @@ Requires-Dist: openinference-instrumentation-crewai
 Requires-Dist: openinference-instrumentation-haystack
 Requires-Dist: openinference-instrumentation-openai-agents
 Requires-Dist: openinference-instrumentation-smolagents
+Requires-Dist: openinference-instrumentation-google-adk
 Requires-Dist: opentelemetry-sdk
 Requires-Dist: opentelemetry-exporter-otlp
 Requires-Dist: opentelemetry-proto>=1.12.0

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/pyproject.toml

@@ -8,7 +8,7 @@ description = "RAGA AI CATALYST"
 readme = "README.md"
 requires-python = ">=3.10,<=3.13.2"
 # license = {file = "LICENSE"}
-version = "2.2.4.2.beta.1"
+version = "2.2.5"
 authors = [
     {name = "Kiran Scaria", email = "kiran.scaria@raga.ai"},
     {name = "Kedar Gaikwad", email = "kedar.gaikwad@raga.ai"},
@@ -57,6 +57,7 @@ dependencies = [
     "openinference-instrumentation-haystack",
     "openinference-instrumentation-openai-agents",
     "openinference-instrumentation-smolagents",
+    "openinference-instrumentation-google-adk",
     "opentelemetry-sdk",
     "opentelemetry-exporter-otlp",
     "opentelemetry-proto>=1.12.0",

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/__init__.py

@@ -1,4 +1,3 @@
-from .experiment import Experiment
 from .ragaai_catalyst import RagaAICatalyst
 from .utils import response_checker
 from .dataset import Dataset
@@ -15,7 +14,6 @@ from .redteaming import RedTeaming
 
 
 __all__ = [
-    "Experiment", 
     "RagaAICatalyst", 
     "Tracer", 
     "PromptManager", 

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/dataset.py

@@ -732,4 +732,62 @@ class Dataset:
                 try:
                     os.remove(tmp_csv_path)
                 except Exception as e:
-                    logger.error(f"Error removing temporary CSV file: {e}")
+                    logger.error(f"Error removing temporary CSV file: {e}")
+    
+    def delete_dataset(self, dataset_name):
+        try:
+            def make_request():
+                headers = {
+                    'Content-Type': 'application/json',
+                    "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                    "X-Project-Id": str(self.project_id),
+                }
+                json_data = {"size": 99999, "page": "0", "projectId": str(self.project_id), "search": ""}
+                try:
+                    response = requests.post(
+                        f"{Dataset.BASE_URL}/v2/llm/dataset",
+                        headers=headers,
+                        json=json_data,
+                        timeout=Dataset.TIMEOUT,
+                    )
+                    response.raise_for_status()
+                    return response
+                except requests.exceptions.RequestException as e:
+                    logger.error(f"Failed to list datasets: {e}")
+                    pass
+
+            response = make_request()
+
+            datasets = response.json()["data"]["content"]
+            dataset_list = [dataset["name"] for dataset in datasets]
+            if dataset_name not in dataset_list:
+                logger.error(f"Dataset '{dataset_name}' does not exists. Please enter a existing dataset name")
+                return
+            
+            # Get dataset id
+            dataset_id = [dataset["id"] for dataset in datasets if dataset["name"] == dataset_name][0]
+            
+            response = requests.delete(
+                f"{Dataset.BASE_URL}/v1/llm/dataset/{int(dataset_id)}",
+                headers={
+                    'Authorization': f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                    "X-Project-Id": str(self.project_id)
+                },
+                timeout=Dataset.TIMEOUT
+            )
+            response.raise_for_status()
+            if response.json()["success"]:
+                print(f"Dataset '{dataset_name}' deleted successfully")
+            else:
+                logger.error("Request was not successful")
+        except requests.exceptions.HTTPError as http_err:
+            logger.error(f"HTTP error occurred: {http_err}")
+        except requests.exceptions.ConnectionError as conn_err:
+            logger.error(f"Connection error occurred: {conn_err}")
+        except requests.exceptions.Timeout as timeout_err:
+            logger.error(f"Timeout error occurred: {timeout_err}")
+        except requests.exceptions.RequestException as req_err:
+            logger.error(f"An error occurred: {req_err}")
+        except Exception as e:
+            logger.error(f"An unexpected error occurred: {e}")
+        

ragaai_catalyst-2.2.5/ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py

@@ -0,0 +1,117 @@
+import contextvars
+from typing import Optional, Dict
+import json
+from datetime import datetime
+import uuid
+import os
+import builtins
+from pathlib import Path
+import logging
+logger = logging.getLogger(__name__)
+
+from ..data.data_structure import (
+    Trace,
+    Metadata,
+    SystemInfo,
+    OSInfo,
+    EnvironmentInfo,
+    Resources,
+    CPUResource,
+    MemoryResource,
+    DiskResource,
+    NetworkResource,
+    ResourceInfo,
+    MemoryInfo,
+    DiskInfo,
+    NetworkInfo,
+    Component,
+    LLMComponent,
+    AgentComponent,
+    ToolComponent,
+    NetworkCall,
+    Interaction,
+    Error,
+)
+
+from ....ragaai_catalyst import RagaAICatalyst
+
+
+class AgenticTracing():
+    def __init__(self, user_detail, auto_instrumentation=None, timeout=120):
+        self.project_name = user_detail["project_name"]
+        self.project_id = user_detail["project_id"]
+        self.trace_user_detail = user_detail["trace_user_detail"]
+        self.base_url = f"{RagaAICatalyst.BASE_URL}"
+        self.timeout = timeout
+        
+        # Add warning flag
+        self._warning_shown = False
+
+        self.tools: Dict[str, Tool] = {}
+        self.call_depth = contextvars.ContextVar("call_depth", default=0)
+        self.current_component_id = contextvars.ContextVar(
+            "current_component_id", default=None
+        )
+
+        # Handle auto_instrumentation
+        if auto_instrumentation is None:
+            # Default behavior: everything enabled
+            self.is_active = True
+            self.auto_instrument_llm = True
+            self.auto_instrument_tool = True
+            self.auto_instrument_agent = True
+            self.auto_instrument_user_interaction = True
+            self.auto_instrument_file_io = True
+            self.auto_instrument_network = True
+            self.auto_instrument_custom = True
+        else:
+            # Set global active state
+            self.is_active = True
+
+            # Set individual components
+            if isinstance(auto_instrumentation, dict):
+                self.auto_instrument_llm = auto_instrumentation.get("llm", True)
+                self.auto_instrument_tool = auto_instrumentation.get("tool", True)
+                self.auto_instrument_agent = auto_instrumentation.get("agent", True)
+                self.auto_instrument_user_interaction = auto_instrumentation.get(
+                    "user_interaction", True
+                )
+                self.auto_instrument_file_io = auto_instrumentation.get(
+                    "file_io", True
+                )
+                self.auto_instrument_network = auto_instrumentation.get(
+                    "network", True
+                )
+                self.auto_instrument_custom = auto_instrumentation.get("custom", True)
+            else:
+                # If boolean provided, apply to all components
+                self.auto_instrument_llm = bool(auto_instrumentation)
+                self.auto_instrument_tool = bool(auto_instrumentation)
+                self.auto_instrument_agent = bool(auto_instrumentation)
+                self.auto_instrument_user_interaction = bool(auto_instrumentation)
+                self.auto_instrument_file_io = bool(auto_instrumentation)
+                self.auto_instrument_network = bool(auto_instrumentation)
+                self.auto_instrument_custom = bool(auto_instrumentation)
+
+        self.current_agent_id = contextvars.ContextVar("current_agent_id", default=None)
+        self.agent_children = contextvars.ContextVar("agent_children", default=[])
+        self.component_network_calls = {}  # Store network calls per component
+        self.component_user_interaction = {}
+
+
+    def register_post_processor(self, post_processor_func):
+        """
+        Pass through the post-processor registration to the BaseTracer
+        """
+        if not callable(post_processor_func):
+            logger.error("post_processor_func must be a callable")
+        self.post_processor = post_processor_func
+
+    def __enter__(self):
+        """Context manager entry"""
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        """Context manager exit"""
+        self.stop()

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/tracers/agentic_tracing/upload/trace_uploader.py

@@ -240,6 +240,7 @@ def process_upload(task_id: str, filepath: str, hash_id: str, zip_path: str,
                     user_details=user_details,
                     timeout=timeout
                 )
+
                 if response is None:
                     logger.error(f"Dataset schema creation failed for {dataset_name} - received None response")
                 elif hasattr(response, 'status_code') and response.status_code in [200, 201]:
@@ -480,7 +481,8 @@ def submit_upload_task(filepath, hash_id, zip_path, project_name, project_id, da
         
         return task_id
     except RuntimeError as e:
-        if "cannot schedule new futures after shutdown" in str(e):
+        if any(msg in str(e) for msg in
+               ("cannot schedule new futures after shutdown", "cannot schedule new futures after interpreter shutdown")):
             logger.warning(f"Executor already shut down, falling back to synchronous processing: {e}")
             return do_sync_processing()
         else:

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py

@@ -9,8 +9,6 @@ from requests.exceptions import ConnectionError, Timeout, RequestException
 from http.client import RemoteDisconnected
 from .session_manager import session_manager
 
-import requests
-
 logger = logging.getLogger(__name__)
 
 from ragaai_catalyst.ragaai_catalyst import RagaAICatalyst
@@ -65,7 +63,7 @@ class UploadAgenticTraces:
                 presignedurl = self.update_presigned_url(presignedURLs, self.base_url)
                 return presignedurl
             elif response.status_code == 401:
-                logger.warning("Received 401 error. Attempting to refresh token.")
+                logger.warning("Received 401 error while getting presign url. Attempting to refresh token.")
                 token = RagaAICatalyst.get_token(force_refresh=True)
                 headers = {
                     "Content-Type": "application/json",
@@ -90,7 +88,8 @@ class UploadAgenticTraces:
                     return None
             else:
                 # If POST fails, try GET
-                logger.warning(f"POST request failed for presign url with status {response.status_code}. Falling back to GET request.")
+                logger.warning(
+                    f"POST request failed for getting presign url with status{response.status_code}.Falling back to GET request.")
                 response = session_manager.make_request_with_retry(
                     "GET", endpoint, headers=headers, data=payload, timeout=self.timeout
                 )
@@ -105,7 +104,7 @@ class UploadAgenticTraces:
                     )
                     return presignedurl
                 elif response.status_code == 401:
-                    logger.warning("Received 401 error. Attempting to refresh token.")
+                    logger.warning("Received 401 error while getting presign url. Attempting to refresh token.")
                     token = RagaAICatalyst.get_token(force_refresh=True)
                     headers = {
                         "Content-Type": "application/json",
@@ -131,7 +130,7 @@ class UploadAgenticTraces:
                         return presignedurl
                     else:
                         logger.error(
-                            f"Error while getting presigned url: {response.json()['message']}"
+                            f"Error while getting presigned url after token refresh: {response.json()['message']}"
                         )
                         return None
                 else:

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py

@@ -8,8 +8,6 @@ from urllib3.exceptions import PoolError, MaxRetryError, NewConnectionError
 from requests.exceptions import ConnectionError, Timeout, RequestException
 from http.client import RemoteDisconnected
 
-import requests
-
 from ragaai_catalyst.ragaai_catalyst import RagaAICatalyst
 from .session_manager import session_manager
 
@@ -106,7 +104,7 @@ def _fetch_dataset_code_hashes(project_name, dataset_name, base_url=None, timeou
         session_manager.handle_request_exceptions(e, "fetching dataset code hashes")
         return None
     except RequestException as e:
-        logger.error(f"Failed to list datasets: {e}")
+        logger.error(f"Failed to fetch dataset code hashes: {e}")
         return None
 
 
@@ -142,7 +140,7 @@ def _fetch_presigned_url(project_name, dataset_name, base_url=None, timeout=120)
         start_time = time.time()
         # Changed to POST from GET
         endpoint = f"{url_base}/v1/llm/presigned-url"
-        response = requests.request(
+        response = session_manager.make_request_with_retry(
             "POST", endpoint, headers=headers, data=payload, timeout=timeout
         )
         elapsed_ms = (time.time() - start_time) * 1000
@@ -150,20 +148,20 @@ def _fetch_presigned_url(project_name, dataset_name, base_url=None, timeout=120)
             f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
         )
 
-        if response.status_code == 200:
+        if response.status_code in [200, 201]:
             presigned_url = response.json()["data"]["presignedUrls"][0]
             presigned_url = update_presigned_url(presigned_url, url_base)
             return presigned_url
         else:
             # If POST fails, try GET
-            response = requests.request(
+            response = session_manager.make_request_with_retry(
                 "POST", endpoint, headers=headers, data=payload, timeout=timeout
             )
             elapsed_ms = (time.time() - start_time) * 1000
             logger.debug(
                 f"API Call: [POST] {endpoint} | Status: {response.status_code} | Time: {elapsed_ms:.2f}ms"
             )
-            if response.status_code == 200:
+            if response.status_code in [200, 201]:
                 presigned_url = response.json()["data"]["presignedUrls"][0]
                 presigned_url = update_presigned_url(presigned_url, url_base)
                 return presigned_url
@@ -175,7 +173,7 @@ def _fetch_presigned_url(project_name, dataset_name, base_url=None, timeout=120)
                     "Content-Type": "application/json",
                     "X-Project-Name": project_name,
                 }
-                response = requests.request(
+                response = session_manager.make_request_with_retry(
                     "POST", endpoint, headers=headers, data=payload, timeout=timeout
                 )
                 elapsed_ms = (time.time() - start_time) * 1000
@@ -188,15 +186,18 @@ def _fetch_presigned_url(project_name, dataset_name, base_url=None, timeout=120)
                     return presigned_url
                 else:
                     logger.error(
-                        f"Failed to fetch code hashes: {response.json()['message']}"
+                        f"Failed to fetch presigned URL for code upload after 401: {response.json()['message']}"
                     )
             else:
                 logger.error(
-                    f"Failed to fetch code hashes: {response.json()['message']}"
+                    f"Failed to fetch presigned URL for code upload: {response.json()['message']}"
                 )
                 return None
-    except requests.exceptions.RequestException as e:
-        logger.error(f"Failed to list datasets: {e}")
+    except (PoolError, MaxRetryError, NewConnectionError, ConnectionError, Timeout, RemoteDisconnected) as e:
+        session_manager.handle_request_exceptions(e, "fetching presigned URL for code upload")
+        return None
+    except RequestException as e:
+        logger.error(f"Failed to fetch presigned URL for code upload: {e}")
         return None
 
 

ragaai_catalyst-2.2.5/ragaai_catalyst/tracers/agentic_tracing/utils/__init__.py

@@ -0,0 +1 @@
+

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/tracers/agentic_tracing/utils/create_dataset_schema.py

@@ -1,8 +1,9 @@
 import os
 import json
-import re
+import requests
 import logging
 import time
+from typing import Optional
 from urllib3.exceptions import PoolError, MaxRetryError, NewConnectionError
 from requests.exceptions import ConnectionError, Timeout, RequestException
 from http.client import RemoteDisconnected
@@ -10,16 +11,26 @@ from http.client import RemoteDisconnected
 from ragaai_catalyst import RagaAICatalyst
 from ragaai_catalyst.tracers.agentic_tracing.upload.session_manager import session_manager
 
+IGNORED_KEYS = {"log_source", "recorded_on"}
 logger = logging.getLogger(__name__)
 
-def create_dataset_schema_with_trace(project_name, dataset_name, base_url=None, user_details=None, timeout=120):
-    SCHEMA_MAPPING = {}
-    metadata = user_details.get("trace_user_detail").get("metadata")
-    if metadata and isinstance(metadata, dict):
+def create_dataset_schema_with_trace(
+        project_name: str,
+        dataset_name: str,
+        base_url: Optional[str] = None,
+        user_details: Optional[dict] = None,
+        timeout: int = 120) -> requests.Response:
+    schema_mapping = {}
+
+    metadata = (
+        user_details.get("trace_user_detail", {}).get("metadata", {})
+        if user_details else {}
+    )
+    if isinstance(metadata, dict):
         for key, value in metadata.items():
-            if key in ["log_source", "recorded_on"]:
+            if key in IGNORED_KEYS:
                 continue
-            SCHEMA_MAPPING[key] = {"columnType": "metadata"}
+            schema_mapping[key] = {"columnType": "metadata"}
 
     headers = {
         "Content-Type": "application/json",
@@ -27,11 +38,11 @@ def create_dataset_schema_with_trace(project_name, dataset_name, base_url=None,
         "X-Project-Name": project_name,
     }
 
-    if SCHEMA_MAPPING:
+    if schema_mapping:
         payload = json.dumps({
             "datasetName": dataset_name,
             "traceFolderUrl": None,
-            "schemaMapping": SCHEMA_MAPPING
+            "schemaMapping": schema_mapping
         })
     else:
         payload = json.dumps({

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/tracers/agentic_tracing/utils/zip_list_of_unique_files.py

@@ -7,6 +7,8 @@ import re
 import ast
 import importlib.util
 import json
+from typing import List, Optional, Tuple
+
 import ipynbname
 from copy import deepcopy
 
@@ -460,8 +462,14 @@ class TraceDependencyTracker:
         logger.debug(f"Zip file created successfully at: {zip_filename}")
         return hash_id, zip_filename
 
-def zip_list_of_unique_files(filepaths, output_dir=None):
+def zip_list_of_unique_files(
+        filepaths: List[str],
+        output_dir: Optional[str] = None
+) -> Tuple[str, str]:
     """Create a zip file containing all unique files and their dependencies."""
+    if not filepaths:
+        logger.warning("The filepaths list is empty. Proceeding with an empty ZIP archive.")
+        filepaths = []
     if output_dir is None:
         # Set default output directory based on environment
         if JupyterNotebookHandler.is_running_in_colab():

{ragaai_catalyst-2.2.4.2b1 → ragaai_catalyst-2.2.5}/ragaai_catalyst/tracers/exporters/__init__.py

@@ -1,7 +1,6 @@
 from .file_span_exporter import FileSpanExporter
-from .raga_exporter import RagaExporter
 from .ragaai_trace_exporter import RAGATraceExporter
 from .dynamic_trace_exporter import DynamicTraceExporter
 
 
-__all__ = ["FileSpanExporter", "RagaExporter", "RAGATraceExporter", "DynamicTraceExporter"]
+__all__ = ["FileSpanExporter", "RAGATraceExporter", "DynamicTraceExporter"]