ragaai-catalyst 2.2.4.2b2__py3-none-any.whl → 2.2.5__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/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/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/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/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

@@ -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,28 +11,38 @@ 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",
         "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
         "X-Project-Name": project_name,
     }
-    logger.info(f"Header for dataset logs api {headers}")
-    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/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/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"]