ragaai-catalyst 2.2.4b5__py3-none-any.whl → 2.2.5b2__py3-none-any.whl

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/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/tracers/agentic_tracing/tracers/main_tracer.py

@@ -7,15 +7,7 @@ import os
 import builtins
 from pathlib import Path
 import logging
-
-from .base import BaseTracer
-from .llm_tracer import LLMTracerMixin
-from .tool_tracer import ToolTracerMixin
-from .agent_tracer import AgentTracerMixin
-from .network_tracer import NetworkTracer
-from .user_interaction_tracer import UserInteractionTracer
-from .custom_tracer import CustomTracerMixin
-from ..utils.span_attributes import SpanAttributes
+logger = logging.getLogger(__name__)
 
 from ..data.data_structure import (
     Trace,
@@ -42,20 +34,10 @@ from ..data.data_structure import (
 )
 
 from ....ragaai_catalyst import RagaAICatalyst
-from ragaai_catalyst.tracers.upload_traces import UploadTraces
 
 
-class AgenticTracing(
-    BaseTracer, LLMTracerMixin, ToolTracerMixin, AgentTracerMixin, CustomTracerMixin
-):
+class AgenticTracing():
     def __init__(self, user_detail, auto_instrumentation=None, timeout=120):
-        # Initialize all parent classes
-        self.user_interaction_tracer = UserInteractionTracer()
-        LLMTracerMixin.__init__(self)
-        ToolTracerMixin.__init__(self)
-        AgentTracerMixin.__init__(self)
-        CustomTracerMixin.__init__(self)
-
         self.project_name = user_detail["project_name"]
         self.project_id = user_detail["project_id"]
         self.trace_user_detail = user_detail["trace_user_detail"]
@@ -65,14 +47,11 @@ class AgenticTracing(
         # Add warning flag
         self._warning_shown = False
 
-        BaseTracer.__init__(self, user_detail)
-
         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
         )
-        self.network_tracer = NetworkTracer()
 
         # Handle auto_instrumentation
         if auto_instrumentation is None:
@@ -120,272 +99,13 @@ class AgenticTracing(
         self.component_user_interaction = {}
 
 
-    def start_component(self, component_id: str):
-        """Start tracking network calls for a component"""
-        self.component_network_calls[component_id] = []
-        self.network_tracer.network_calls = []  # Reset network calls
-        self.current_component_id.set(component_id)
-        self.user_interaction_tracer.component_id.set(component_id)
-
-    def end_component(self, component_id: str):
-        """End tracking network calls for a component"""
-        self.component_network_calls[component_id] = (
-            self.network_tracer.network_calls.copy()
-        )
-        self.network_tracer.network_calls = []  # Reset for next component
-
-        # Store user interactions for the component
-        for interaction in self.user_interaction_tracer.interactions:
-            interaction_component_id = interaction.get("component_id")
-            if interaction_component_id not in self.component_user_interaction:
-                self.component_user_interaction[interaction_component_id] = []
-            if interaction not in self.component_user_interaction[interaction_component_id]:
-                self.component_user_interaction[interaction_component_id].append(interaction)
-                
-        # Only reset component_id if it matches the current one
-        # This ensures we don't reset a parent's component_id when a child component ends
-        if self.current_component_id.get() == component_id:
-            # Get the parent agent's component_id if it exists
-            parent_agent_id = self.current_agent_id.get()
-            # If there's a parent agent, set the component_id back to the parent's
-            if parent_agent_id:
-                self.current_component_id.set(parent_agent_id)
-                self.user_interaction_tracer.component_id.set(parent_agent_id)
-            else:
-                # Only reset to None if there's no parent
-                self.current_component_id.set(None)
-                self.user_interaction_tracer.component_id.set(None)
-
     def register_post_processor(self, post_processor_func):
         """
         Pass through the post-processor registration to the BaseTracer
         """
-        super().register_post_processor(post_processor_func)
-
-    def start(self):
-        """Start tracing"""
-        self.is_active = True
-
-        # Setup user interaction tracing
-        self.user_interaction_tracer.project_id.set(self.project_id)
-        self.user_interaction_tracer.trace_id.set(self.trace_id)
-        self.user_interaction_tracer.tracer = self
-        self.user_interaction_tracer.component_id.set(self.current_component_id.get())
-
-        # Start base tracer (includes system info and resource monitoring)
-        super().start()
-
-        # Activate network tracing
-        self.network_tracer.activate_patches()
-
-        # take care of the auto instrumentation
-        if self.auto_instrument_user_interaction:
-            ToolTracerMixin.instrument_user_interaction_calls(self)
-            LLMTracerMixin.instrument_user_interaction_calls(self)
-            AgentTracerMixin.instrument_user_interaction_calls(self)
-            CustomTracerMixin.instrument_user_interaction_calls(self)
-            builtins.print = self.user_interaction_tracer.traced_print
-            builtins.input = self.user_interaction_tracer.traced_input
-
-        if self.auto_instrument_network:
-            ToolTracerMixin.instrument_network_calls(self)
-            LLMTracerMixin.instrument_network_calls(self)
-            AgentTracerMixin.instrument_network_calls(self)
-            CustomTracerMixin.instrument_network_calls(self)
-
-        if self.auto_instrument_file_io:
-            ToolTracerMixin.instrument_file_io_calls(self)
-            LLMTracerMixin.instrument_file_io_calls(self)
-            AgentTracerMixin.instrument_file_io_calls(self)
-            CustomTracerMixin.instrument_file_io_calls(self)
-            builtins.open = self.user_interaction_tracer.traced_open
-            
-        if self.auto_instrument_llm:
-            self.instrument_llm_calls()
-
-        if self.auto_instrument_tool:
-            self.instrument_tool_calls()
-
-        if self.auto_instrument_agent:
-            self.instrument_agent_calls()
-
-        if self.auto_instrument_custom:
-            self.instrument_custom_calls()
-
-    def stop(self):
-        """Stop tracing and save results"""
-        if self.is_active:
-            # Restore original print and input functions
-            builtins.print = self.user_interaction_tracer.original_print
-            builtins.input = self.user_interaction_tracer.original_input
-            builtins.open = self.user_interaction_tracer.original_open
-
-            # Calculate final metrics before stopping
-            self._calculate_final_metrics()
-
-            # Deactivate network tracing
-            self.network_tracer.deactivate_patches()
-
-            # Clear visited metrics when stopping trace
-            self.visited_metrics.clear()
-
-            # Stop base tracer (includes saving to file)
-            super().stop()
-
-            # Cleanup
-            self.unpatch_llm_calls()
-            self.user_interaction_tracer.interactions = []  # Clear interactions list
-            self.is_active = False
-
-    def _calculate_final_metrics(self):
-        """Calculate total cost and tokens from all components"""
-        total_cost = 0.0
-        total_tokens = 0
-
-        processed_components = set()
-
-        def process_component(component):
-            nonlocal total_cost, total_tokens
-            # Convert component to dict if it's an object
-            comp_dict = (
-                component.__dict__ if hasattr(component, "__dict__") else component
-            )
-
-            comp_id = comp_dict.get("id") or comp_dict.get("component_id")
-            if comp_id in processed_components:
-                return  # Skip if already processed
-            processed_components.add(comp_id)
-
-            if comp_dict.get("type") == "llm":
-                info = comp_dict.get("info", {})
-                if isinstance(info, dict):
-                    # Extract cost
-                    cost_info = info.get("cost", {})
-                    if isinstance(cost_info, dict):
-                        total_cost += cost_info.get("total_cost", 0)
-
-                    # Extract tokens
-                    token_info = info.get("tokens", {})
-                    if isinstance(token_info, dict):
-                        total_tokens += token_info.get("total_tokens", 0)
-                    else:
-                        token_info = info.get("token_usage", {})
-                        if isinstance(token_info, dict):
-                            total_tokens += token_info.get("total_tokens", 0)
-
-            # Process children if they exist
-            data = comp_dict.get("data", {})
-            if isinstance(data, dict):
-                children = data.get("children", [])
-                if children:
-                    for child in children:
-                        process_component(child)
-
-        # Process all root components
-        for component in self.components:
-            process_component(component)
-
-        # Update metadata in trace
-        if hasattr(self, "trace"):
-            if isinstance(self.trace.metadata, dict):
-                self.trace.metadata["total_cost"] = total_cost
-                self.trace.metadata["total_tokens"] = total_tokens
-            else:
-                self.trace.metadata.total_cost = total_cost
-                self.trace.metadata.total_tokens = total_tokens
-
-    def add_component(self, component_data: dict, is_error: bool = False):
-        """Add a component to the trace data"""
-        # Convert dict to appropriate Component type
-        filtered_data = {
-            k: v
-            for k, v in component_data.items()
-            if k
-            in [
-                "id",
-                "hash_id",
-                "source_hash_id",
-                "type",
-                "name",
-                "start_time",
-                "end_time",
-                "parent_id",
-                "info",
-                "extra_info",
-                "data",
-                "metadata",
-                "metrics",
-                "feedback",
-                "network_calls",
-                "interactions",
-                "error",
-            ]
-        }
-
-        if component_data == None or component_data == {} or component_data.get("type", None) == None:
-            # Only show warning if it hasn't been shown before
-            if not self._warning_shown:
-                import toml
-                import os
-                from pathlib import Path
-
-                # Load supported LLM calls from TOML file
-                current_dir = Path(__file__).parent
-                toml_path = current_dir / "../utils/supported_llm_provider.toml"
-                try:
-                    with open(toml_path, "r") as f:
-                        config = toml.load(f)
-                        supported_calls = ", ".join(config["supported_llm_calls"])
-                except Exception as e:
-                    supported_calls = "Error loading supported LLM calls"
-
-                # ANSI escape codes for colors and formatting
-                RED = "\033[91m"
-                BOLD = "\033[1m"
-                RESET = "\033[0m"
-                BIG = "\033[1;2m"  # Makes text slightly larger in supported terminals
-
-                warning_msg = f"""{RED}{BOLD}{BIG}
-╔════════════════════════ COMPONENT DATA INCOMPLETE ════════════════════════╗
-║                                                                          ║
-║  Please ensure these requirements:                                       ║
-║  ✗ trace_llm decorator must have a stand alone llm call                 ║
-║  ✗ trace_tool decorator must be a stand alone tool/function call        ║
-║  ✗ trace_agent decorator can have multiple/nested llm/tool/agent calls  ║
-║                                                                          ║
-║  Supported LLM calls:                                                    ║
-║  {supported_calls}                                                       ║
-║                                                                          ║
-╚══════════════════════════════════════════════════════════════════════════╝
-{RESET}"""
-                # Use logger.warning for the message
-                logging.warning(warning_msg)
-                self._warning_shown = True
-            return
-
-        if component_data["type"] == "llm":
-            component = LLMComponent(**filtered_data)
-        elif component_data["type"] == "agent":
-            component = AgentComponent(**filtered_data)
-        elif component_data["type"] == "tool":
-            component = ToolComponent(**filtered_data)
-        else:
-            component = Component(**component_data)
-
-        # Check if there's an active agent context
-        current_agent_id = self.current_agent_id.get()
-        if current_agent_id and component_data["type"] in ["llm", "tool", "custom"]:
-            # Add this component as a child of the current agent
-            current_children = self.agent_children.get()
-            current_children.append(component_data)
-            self.agent_children.set(current_children)
-        else:
-            # Add component to the main trace
-            super().add_component(component)
-
-        # Handle error case
-        if is_error and not self.current_agent_id.get():
-            self.stop()
+        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"""

ragaai_catalyst/tracers/agentic_tracing/utils/__init__.py

@@ -1,3 +1 @@
-from .generic import get_db_path
 
-__all__ = ["get_db_path"]

ragaai_catalyst/tracers/agentic_tracing/utils/create_dataset_schema.py

@@ -2,7 +2,7 @@ import os
 import json
 import re
 import requests
-from ragaai_catalyst.tracers.agentic_tracing.tracers.base import RagaAICatalyst
+from ragaai_catalyst import RagaAICatalyst
 
 def create_dataset_schema_with_trace(project_name, dataset_name, base_url=None, user_details=None, timeout=120):
     SCHEMA_MAPPING = {}

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"]

ragaai_catalyst/tracers/exporters/file_span_exporter.py

@@ -9,7 +9,6 @@ import asyncio
 from concurrent.futures import ThreadPoolExecutor
 from opentelemetry.sdk.trace.export import SpanExporter
 from ..utils import get_unique_key
-from .raga_exporter import RagaExporter
 
 # Set up logging
 logging.basicConfig(level=logging.INFO)

ragaai_catalyst/tracers/exporters/ragaai_trace_exporter.py

@@ -6,7 +6,6 @@ from dataclasses import asdict
 
 from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
-from ragaai_catalyst.tracers.agentic_tracing.tracers.base import TracerJSONEncoder
 from ragaai_catalyst.tracers.agentic_tracing.upload.trace_uploader import (
     submit_upload_task,
 )
@@ -24,6 +23,29 @@ logging_level = (
     logger.setLevel(logging.DEBUG) if os.getenv("DEBUG") == "1" else logging.INFO
 )
 
+class TracerJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, datetime):
+            return obj.isoformat()
+        if isinstance(obj, bytes):
+            try:
+                return obj.decode("utf-8")
+            except UnicodeDecodeError:
+                return str(obj)  # Fallback to string representation
+        if hasattr(obj, "to_dict"):  # Handle objects with to_dict method
+            return obj.to_dict()
+        if hasattr(obj, "__dict__"):
+            # Filter out None values and handle nested serialization
+            return {
+                k: v
+                for k, v in obj.__dict__.items()
+                if v is not None and not k.startswith("_")
+            }
+        try:
+            # Try to convert to a basic type
+            return str(obj)
+        except:
+            return None  # Last resort: return None instead of failing
 
 class RAGATraceExporter(SpanExporter):
     def __init__(self, tracer_type, files_to_zip, project_name, project_id, dataset_name, user_details, base_url, custom_model_cost, timeout=120, post_processor = None, max_upload_workers = 30,user_context = None, user_gt = None, external_id=None):