ragaai-catalyst 2.1b5__py3-none-any.whl → 2.1.1__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/{agentic_tracing.py → tracers/main_tracer.py}

@@ -14,7 +14,7 @@ from .agent_tracer import AgentTracerMixin
 from .network_tracer import NetworkTracer
 from .user_interaction_tracer import UserInteractionTracer
 
-from .data_structure import (
+from ..data.data_structure import (
     Trace, Metadata, SystemInfo, OSInfo, EnvironmentInfo,
     Resources, CPUResource, MemoryResource, DiskResource, NetworkResource,
     ResourceInfo, MemoryInfo, DiskInfo, NetworkInfo,
@@ -22,9 +22,8 @@ from .data_structure import (
     NetworkCall, Interaction, Error
 )
 
-
-from ...ragaai_catalyst import RagaAICatalyst
-from ..upload_traces import UploadTraces
+from ....ragaai_catalyst import RagaAICatalyst
+from ragaai_catalyst.tracers.upload_traces import UploadTraces
 
 class AgenticTracing(BaseTracer, LLMTracerMixin, ToolTracerMixin, AgentTracerMixin):
     def __init__(self, user_detail, auto_instrument_llm: bool = True):
@@ -164,12 +163,11 @@ class AgenticTracing(BaseTracer, LLMTracerMixin, ToolTracerMixin, AgentTracerMix
                 self.trace.metadata.total_cost = total_cost
                 self.trace.metadata.total_tokens = total_tokens
 
-    def add_component(self, component_data: dict):
+    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", "type", "name", "start_time", "end_time", "parent_id", "info", "data", "network_calls", "interactions", "error"]}
 
-               
         if component_data["type"] == "llm":
             component = LLMComponent(**filtered_data)
         elif component_data["type"] == "agent": 
@@ -179,8 +177,6 @@ class AgenticTracing(BaseTracer, LLMTracerMixin, ToolTracerMixin, AgentTracerMix
         else:
             component = Component(**component_data)
 
-        # import pdb; pdb.set_trace()
-        
         # 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"]:
@@ -191,6 +187,43 @@ class AgenticTracing(BaseTracer, LLMTracerMixin, ToolTracerMixin, AgentTracerMix
         else:
             # Add component to the main trace
             super().add_component(component)
+            
+        # Handle error case
+        if is_error:
+            # Get the parent component if it exists
+            parent_id = component_data.get("parent_id")
+            children = self.agent_children.get()
+            
+            # Set parent_id for all children
+            for child in children:
+                child["parent_id"] = parent_id
+            
+            agent_tracer_mixin = AgentTracerMixin()
+            agent_tracer_mixin.component_network_calls = self.component_network_calls
+            agent_tracer_mixin.component_user_interaction = self.component_user_interaction
+            
+            # Create parent component with error info
+            parent_component = agent_tracer_mixin.create_agent_component(
+                component_id=parent_id,
+                hash_id=str(uuid.uuid4()),
+                name=self.current_agent_name.get(),
+                agent_type=self.agent_type.get(),
+                version=self.version.get(),
+                capabilities=self.capabilities.get(),
+                start_time=self.start_time,
+                end_time=datetime.now(),
+                memory_used=0,
+                input_data=self.input_data,
+                output_data=None,
+                children=children,
+                parent_id=None  # Add parent ID if exists
+            )
+
+            filtered_data = {k: v for k, v in parent_component.items() if k in ["id", "hash_id", "type", "name", "start_time", "end_time", "parent_id", "info", "data", "network_calls", "interactions", "error"]}
+            parent_agent_component = AgentComponent(**filtered_data)
+            # Add the parent component to trace and stop tracing
+            super().add_component(parent_agent_component)
+            self.stop()
 
     def __enter__(self):
         """Context manager entry"""

ragaai_catalyst/tracers/agentic_tracing/{tool_tracer.py → tracers/tool_tracer.py}

@@ -1,12 +1,12 @@
-import functools
 import uuid
 from datetime import datetime
 import psutil
+import functools
 from typing import Optional, Any, Dict, List
-from .unique_decorator import generate_unique_hash_simple  
+from ..utils.unique_decorator import generate_unique_hash_simple, mydecorator
 import contextvars
 import asyncio
-from .file_name_tracker import TrackName
+from ..utils.file_name_tracker import TrackName
 
 
 class ToolTracerMixin:

ragaai_catalyst/tracers/agentic_tracing/{upload_agentic_traces.py → upload/upload_agentic_traces.py}

@@ -131,6 +131,9 @@ class UploadAgenticTraces:
                                         headers=headers, 
                                         data=payload,
                                         timeout=self.timeout)
+            if response.status_code != 200:
+                print(f"Error inserting traces: {response.json()['message']}")
+                return None
         except requests.exceptions.RequestException as e:
             print(f"Error while inserting traces: {e}")
             return None

ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py

@@ -1,4 +1,4 @@
-from .data_classes import LLMCall
+from ..data.data_structure import LLMCall
 from .trace_utils import (
     calculate_cost,
     convert_usage_to_dict,
@@ -7,22 +7,237 @@ from .trace_utils import (
 from importlib import resources
 import json
 import os
+import asyncio
+import psutil
 
 
-# Load the Json configuration
-try:
-    current_dir = os.path.dirname(os.path.abspath(__file__))
-    model_costs_path = os.path.join(current_dir, "model_costs.json")
-    with open(model_costs_path, "r") as file:
-        config = json.load(file)
-except FileNotFoundError:
-    from importlib.resources import files
-    with (files("") / "model_costs.json").open("r") as file:
-        config = json.load(file)
+def extract_model_name(args, kwargs, result):
+    """Extract model name from kwargs or result"""
+    # First try direct model parameter
+    model = kwargs.get("model", "")
+    
+    if not model:
+        # Try to get from instance
+        instance = kwargs.get("self", None)
+        if instance:
+            # Try model_name first (Google format)
+            if hasattr(instance, "model_name"):
+                model = instance.model_name
+            # Try model attribute
+            elif hasattr(instance, "model"):
+                model = instance.model
+    
+    # Normalize Google model names
+    if model and isinstance(model, str):
+        model = model.lower()
+        if "gemini-1.5-flash" in model:
+            return "gemini-1.5-flash"
+        if "gemini-1.5-pro" in model:
+            return "gemini-1.5-pro"
+        if "gemini-pro" in model:
+            return "gemini-pro"
 
+    if 'to_dict' in dir(result):
+        result = result.to_dict()
+        if 'model_version' in result:
+            model = result['model_version']
+    
+    return model or "default"
+
+
+def extract_parameters(kwargs):
+    """Extract all non-null parameters from kwargs"""
+    parameters = {k: v for k, v in kwargs.items() if v is not None}
+
+    # Remove contents key in parameters (Google LLM Response)
+    if 'contents' in parameters:
+        del parameters['contents']
+
+    # Remove messages key in parameters (OpenAI message)
+    if 'messages' in parameters:
+        del parameters['messages']
+
+    if 'generation_config' in parameters:
+        generation_config = parameters['generation_config']
+        # If generation_config is already a dict, use it directly
+        if isinstance(generation_config, dict):
+            config_dict = generation_config
+        else:
+            # Convert GenerationConfig to dictionary if it has a to_dict method, otherwise try to get its __dict__
+            config_dict = getattr(generation_config, 'to_dict', lambda: generation_config.__dict__)()
+        parameters.update(config_dict)
+        del parameters['generation_config']
+        
+    return parameters
+
+
+def extract_token_usage(result):
+    """Extract token usage from result"""
+    # Handle coroutines
+    if asyncio.iscoroutine(result):
+        # Get the current event loop
+        loop = asyncio.get_event_loop()
+        # Run the coroutine in the current event loop
+        result = loop.run_until_complete(result)
+
+    # Handle standard OpenAI/Anthropic format
+    if hasattr(result, "usage"):
+        usage = result.usage
+        return {
+            "prompt_tokens": getattr(usage, "prompt_tokens", 0),
+            "completion_tokens": getattr(usage, "completion_tokens", 0),
+            "total_tokens": getattr(usage, "total_tokens", 0)
+        }
+    
+    # Handle Google GenerativeAI format with usage_metadata
+    if hasattr(result, "usage_metadata"):
+        metadata = result.usage_metadata
+        return {
+            "prompt_tokens": getattr(metadata, "prompt_token_count", 0),
+            "completion_tokens": getattr(metadata, "candidates_token_count", 0),
+            "total_tokens": getattr(metadata, "total_token_count", 0)
+        }
+    
+    # Handle Vertex AI format
+    if hasattr(result, "text"):
+        # For LangChain ChatVertexAI
+        total_tokens = getattr(result, "token_count", 0)
+        if not total_tokens and hasattr(result, "_raw_response"):
+            # Try to get from raw response
+            total_tokens = getattr(result._raw_response, "token_count", 0)
+        return {
+            "prompt_tokens": 0,  # Vertex AI doesn't provide this breakdown
+            "completion_tokens": total_tokens,
+            "total_tokens": total_tokens
+        }
+    
+    return {
+        "prompt_tokens": 0,
+        "completion_tokens": 0,
+        "total_tokens": 0
+    }
+
+
+def extract_input_data(args, kwargs, result):
+    """Extract input data from function call"""
+    return {
+        'args': args,
+        'kwargs': kwargs
+    }
+
+
+def calculate_llm_cost(token_usage, model_name, model_costs):
+    """Calculate cost based on token usage and model"""
+    if not isinstance(token_usage, dict):
+        token_usage = {
+            "prompt_tokens": 0,
+            "completion_tokens": 0,
+            "total_tokens": token_usage if isinstance(token_usage, (int, float)) else 0
+        }
+
+    # Get model costs, defaulting to default costs if unknown
+    model_cost = model_costs.get(model_name, {
+        "input_cost_per_token": 0.0,   
+        "output_cost_per_token": 0.0   
+    })
+
+    input_cost = (token_usage.get("prompt_tokens", 0)) * model_cost.get("input_cost_per_token", 0.0)
+    output_cost = (token_usage.get("completion_tokens", 0)) * model_cost.get("output_cost_per_token", 0.0)
+    total_cost = input_cost + output_cost
+
+    return {
+        "input_cost": round(input_cost, 10),
+        "output_cost": round(output_cost, 10),
+        "total_cost": round(total_cost, 10)
+    }
+
+
+def sanitize_api_keys(data):
+    """Remove sensitive information from data"""
+    if isinstance(data, dict):
+        return {k: sanitize_api_keys(v) for k, v in data.items() 
+                if not any(sensitive in k.lower() for sensitive in ['key', 'token', 'secret', 'password'])}
+    elif isinstance(data, list):
+        return [sanitize_api_keys(item) for item in data]
+    elif isinstance(data, tuple):
+        return tuple(sanitize_api_keys(item) for item in data)
+    return data
+
+
+def sanitize_input(args, kwargs):
+    """Convert input arguments to text format.
+    
+    Args:
+        args: Input arguments that may contain nested dictionaries
+        
+    Returns:
+        str: Text representation of the input arguments
+    """
+    if isinstance(args, dict):
+        return str({k: sanitize_input(v, {}) for k, v in args.items()})
+    elif isinstance(args, (list, tuple)):
+        return str([sanitize_input(item, {}) for item in args])
+    return str(args)
 
 
 def extract_llm_output(result):
+    """Extract output from LLM response"""
+    class OutputResponse:
+        def __init__(self, output_response):
+            self.output_response = output_response
+
+    # Handle coroutines
+    if asyncio.iscoroutine(result):
+        # For sync context, run the coroutine
+        if not asyncio.get_event_loop().is_running():
+            result = asyncio.run(result)
+        else:
+            # We're in an async context, but this function is called synchronously
+            # Return a placeholder and let the caller handle the coroutine
+            return OutputResponse("Coroutine result pending")
+
+    # Handle Google GenerativeAI format
+    if hasattr(result, "result"):
+        candidates = getattr(result.result, "candidates", [])
+        output = []
+        for candidate in candidates:
+            content = getattr(candidate, "content", None)
+            if content and hasattr(content, "parts"):
+                for part in content.parts:
+                    if hasattr(part, "text"):
+                        output.append({
+                            "content": part.text,
+                            "role": getattr(content, "role", "assistant"),
+                            "finish_reason": getattr(candidate, "finish_reason", None)
+                        })
+        return OutputResponse(output)
+    
+    # Handle Vertex AI format
+    if hasattr(result, "text"):
+        return OutputResponse([{
+            "content": result.text,
+            "role": "assistant"
+        }])
+    
+    # Handle OpenAI format
+    if hasattr(result, "choices"):
+        return OutputResponse([{
+            "content": choice.message.content,
+            "role": choice.message.role
+        } for choice in result.choices])
+    
+    # Handle Anthropic format
+    if hasattr(result, "completion"):
+        return OutputResponse([{
+            "content": result.completion,
+            "role": "assistant"
+        }])
+    
+    # Default case
+    return OutputResponse(str(result))
+
+
+def extract_llm_data(args, kwargs, result):
     # Initialize variables
     model_name = None
     output_response = ""
@@ -32,15 +247,7 @@ def extract_llm_output(result):
     cost = {}
 
     # Try to get model_name from result or result.content
-    model_name = None
-    if hasattr(result, "model"):
-        model_name = result.model
-    elif hasattr(result, "content"):
-        try:
-            content_dict = json.loads(result.content)
-            model_name = content_dict.get("model", None)
-        except (json.JSONDecodeError, TypeError):
-            model_name = None
+    model_name = extract_model_name(args, kwargs, result)
 
     # Try to get choices from result or result.content
     choices = None
@@ -136,34 +343,13 @@ def extract_llm_output(result):
     else:
         usage = {}
 
-    token_usage = convert_usage_to_dict(usage)
+    token_usage = extract_token_usage(result)
 
     # Load model costs
     model_costs = load_model_costs()
 
     # Calculate cost
-    if model_name in model_costs:
-        model_config = model_costs[model_name]
-        input_cost_per_token = model_config.get("input_cost_per_token", 0.0)
-        output_cost_per_token = model_config.get("output_cost_per_token", 0.0)
-        reasoning_cost_per_token = model_config.get(
-            "reasoning_cost_per_token", output_cost_per_token
-        )
-    else:
-        # Default costs or log a warning
-        print(
-            f"Warning: Model '{model_name}' not found in config. Using default costs."
-        )
-        input_cost_per_token = 0.0
-        output_cost_per_token = 0.0
-        reasoning_cost_per_token = 0.0
-
-    cost = calculate_cost(
-        token_usage,
-        input_cost_per_token=input_cost_per_token,
-        output_cost_per_token=output_cost_per_token,
-        reasoning_cost_per_token=reasoning_cost_per_token,
-    )
+    cost = calculate_llm_cost(token_usage, model_name, model_costs)
 
     llm_data = LLMCall(
         name="",

ragaai_catalyst/tracers/tracer.py

@@ -9,19 +9,18 @@ from concurrent.futures import ThreadPoolExecutor
 
 from opentelemetry.sdk import trace as trace_sdk
 from opentelemetry.sdk.trace.export import SimpleSpanProcessor
-from .exporters.file_span_exporter import FileSpanExporter
-from .exporters.raga_exporter import RagaExporter
-from .instrumentators import (
+from ragaai_catalyst.tracers.exporters.file_span_exporter import FileSpanExporter
+from ragaai_catalyst.tracers.exporters.raga_exporter import RagaExporter
+from ragaai_catalyst.tracers.instrumentators import (
     LangchainInstrumentor,
     OpenAIInstrumentor,
     LlamaIndexInstrumentor,
 )
-from .utils import get_unique_key
-# from .llamaindex_callback import LlamaIndexTracer
-from ..ragaai_catalyst import RagaAICatalyst
-from .agentic_tracing.agentic_tracing import AgenticTracing
-from .agentic_tracing.file_name_tracker import TrackName
-from .agentic_tracing.llm_tracer import LLMTracerMixin
+from ragaai_catalyst.tracers.utils import get_unique_key
+# from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
+from ragaai_catalyst import RagaAICatalyst
+from ragaai_catalyst.tracers.agentic_tracing import AgenticTracing, TrackName
+from ragaai_catalyst.tracers.agentic_tracing.tracers.llm_tracer import LLMTracerMixin
 
 logger = logging.getLogger(__name__)
 
@@ -114,7 +113,7 @@ class Tracer(AgenticTracing):
             self._upload_task = None
         elif tracer_type == "llamaindex":
             self._upload_task = None
-            from .llamaindex_callback import LlamaIndexTracer
+            from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
 
         else:
             self._upload_task = None
@@ -176,7 +175,7 @@ class Tracer(AgenticTracing):
             print(f"Tracer started for project: {self.project_name}")
             return self
         elif self.tracer_type == "llamaindex":
-            from .llamaindex_callback import LlamaIndexTracer
+            from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
             return LlamaIndexTracer(self._pass_user_data()).start()
         else:
             super().start()
@@ -194,7 +193,7 @@ class Tracer(AgenticTracing):
             self._upload_task = self._run_async(self._upload_traces())
             return "Trace upload initiated. Use get_upload_status() to check the status."
         elif self.tracer_type == "llamaindex":
-            from .llamaindex_callback import LlamaIndexTracer
+            from ragaai_catalyst.tracers.llamaindex_callback import LlamaIndexTracer
             return LlamaIndexTracer(self._pass_user_data()).stop()
         else:
             super().stop()

{ragaai_catalyst-2.1b5.dist-info → ragaai_catalyst-2.1.1.dist-info}/METADATA

@@ -1,9 +1,9 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: ragaai_catalyst
-Version: 2.1b5
+Version: 2.1.1
 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>
-Requires-Python: >=3.9
+Requires-Python: <3.13,>=3.9
 Description-Content-Type: text/markdown
 Requires-Dist: aiohttp>=3.10.2
 Requires-Dist: opentelemetry-api==1.25.0
@@ -19,7 +19,7 @@ Requires-Dist: opentelemetry-instrumentation-openai~=0.24.0
 Requires-Dist: langchain-core>=0.2.11
 Requires-Dist: langchain>=0.2.11
 Requires-Dist: openai>=1.57.0
-Requires-Dist: pandas>=2.1.1
+Requires-Dist: pandas
 Requires-Dist: groq>=0.11.0
 Requires-Dist: PyPDF2>=3.0.1
 Requires-Dist: google-generativeai>=0.8.2
@@ -27,7 +27,7 @@ Requires-Dist: Markdown>=3.7
 Requires-Dist: litellm==1.51.1
 Requires-Dist: tenacity==8.3.0
 Requires-Dist: tqdm>=4.66.5
-Requires-Dist: llama-index>=0.10.0
+Requires-Dist: llama-index<0.11.0,>=0.10.0
 Requires-Dist: pyopenssl>=24.2.1
 Requires-Dist: psutil~=6.0.0
 Requires-Dist: py-cpuinfo~=9.0.0

ragaai_catalyst-2.1.1.dist-info/RECORD

@@ -0,0 +1,60 @@
+ragaai_catalyst/__init__.py,sha256=BdIJ_UUre0uEnRTsLw_hE0C0muWk6XWNZqdVOel22R4,537
+ragaai_catalyst/_version.py,sha256=JKt9KaVNOMVeGs8ojO6LvIZr7ZkMzNN-gCcvryy4x8E,460
+ragaai_catalyst/dataset.py,sha256=On-iOhD5R7iLusph6dLAGS1dOnNtb1koiKxKjTH90pE,10660
+ragaai_catalyst/evaluation.py,sha256=34H2bYZNSrcu0jMQgDZw1OLVbQU80PaVLo2avju8POM,20311
+ragaai_catalyst/experiment.py,sha256=8KvqgJg5JVnt9ghhGDJvdb4mN7ETBX_E5gNxBT0Nsn8,19010
+ragaai_catalyst/guard_executor.py,sha256=llPbE3DyVtrybojXknzBZj8-dtUrGBQwi9-ZiPJxGRo,3762
+ragaai_catalyst/guardrails_manager.py,sha256=DILMOAASK57FH9BLq_8yC1AQzRJ8McMFLwCXgYwNAd4,11904
+ragaai_catalyst/internal_api_completion.py,sha256=DdICI5yfEudiOAIC8L4oxH0Qz7kX-BZCdo9IWsi2gNo,2965
+ragaai_catalyst/prompt_manager.py,sha256=W8ypramzOprrJ7-22d5vkBXIuIQ8v9XAzKDGxKsTK28,16550
+ragaai_catalyst/proxy_call.py,sha256=CHxldeceZUaLU-to_hs_Kf1z_b2vHMssLS_cOBedu78,5499
+ragaai_catalyst/ragaai_catalyst.py,sha256=FdqMzwuQLqS2-3JJDsTQ8uh2itllOxfPrRUjb8Kwmn0,17428
+ragaai_catalyst/synthetic_data_generation.py,sha256=uDV9tNwto2xSkWg5XHXUvjErW-4P34CTrxaJpRfezyA,19250
+ragaai_catalyst/utils.py,sha256=TlhEFwLyRU690HvANbyoRycR3nQ67lxVUQoUOfTPYQ0,3772
+ragaai_catalyst/tracers/__init__.py,sha256=yxepo7iVjTNI_wFdk3Z6Ghu64SazVyszCPEHYrX5WQk,50
+ragaai_catalyst/tracers/llamaindex_callback.py,sha256=vPE7MieKjfwLrLUnnPs20Df0xNYqoCCj-Mt2NbiuiKU,14023
+ragaai_catalyst/tracers/tracer.py,sha256=ecr90nRvd6iHRc9HaVm79HM0fB875QwS6YNh6HHSCD8,12637
+ragaai_catalyst/tracers/upload_traces.py,sha256=hs0PEmit3n3_uUqrdbwcBdyK5Nbkik3JQVwJMEwYTd4,4796
+ragaai_catalyst/tracers/agentic_tracing/README.md,sha256=X4QwLb7-Jg7GQMIXj-SerZIgDETfw-7VgYlczOR8ZeQ,4508
+ragaai_catalyst/tracers/agentic_tracing/__init__.py,sha256=yf6SKvOPSpH-9LiKaoLKXwqj5sez8F_5wkOb91yp0oE,260
+ragaai_catalyst/tracers/agentic_tracing/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragaai_catalyst/tracers/agentic_tracing/data/data_structure.py,sha256=fv1h5IvVZDj7IYrozW2NL9tdoL2CWWWOPey_LTduNuI,7708
+ragaai_catalyst/tracers/agentic_tracing/tests/FinancialAnalysisSystem.ipynb,sha256=0qZxjWqYCTAVvdo3Tsp544D8Am48wfeMQ9RKpKgAL8g,34291
+ragaai_catalyst/tracers/agentic_tracing/tests/GameActivityEventPlanner.ipynb,sha256=QCMFJYbGX0fd9eMW4PqyQLZjyWuTXo7n1nqO_hMLf0s,4225
+ragaai_catalyst/tracers/agentic_tracing/tests/TravelPlanner.ipynb,sha256=fU3inXoemJbdTkGAQl_N1UwVEZ10LrKv4gCEpbQ4ISg,43481
+ragaai_catalyst/tracers/agentic_tracing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragaai_catalyst/tracers/agentic_tracing/tests/ai_travel_agent.py,sha256=S4rCcKzU_5SB62BYEbNn_1VbbTdG4396N8rdZ3ZNGcE,5654
+ragaai_catalyst/tracers/agentic_tracing/tests/unique_decorator_test.py,sha256=Xk1cLzs-2A3dgyBwRRnCWs7Eubki40FVonwd433hPN8,4805
+ragaai_catalyst/tracers/agentic_tracing/tracers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragaai_catalyst/tracers/agentic_tracing/tracers/agent_tracer.py,sha256=_9yGrHLw9TnKkYaNkWHQaLFQgsi945CClDTpf6JhINk,21372
+ragaai_catalyst/tracers/agentic_tracing/tracers/base.py,sha256=lxr62VIbULd9vqCT30nvuWfokvbm7LLWlsu84m0YQfk,14043
+ragaai_catalyst/tracers/agentic_tracing/tracers/llm_tracer.py,sha256=uAoUm2NyFL27FF6YExtNiXSYVRHTS1YpqmLHu6_eolE,23983
+ragaai_catalyst/tracers/agentic_tracing/tracers/main_tracer.py,sha256=urY3AWI01JAlGe2rjg-K0EV0CFHti4_SUOAXp23ROk4,10246
+ragaai_catalyst/tracers/agentic_tracing/tracers/network_tracer.py,sha256=6FTA15xMnum9omM_0Jd9cMIuWdKu1gR5Tc8fOXAkP8E,10068
+ragaai_catalyst/tracers/agentic_tracing/tracers/tool_tracer.py,sha256=RuxmiOT8DUzpy5oFNjImQDNjYDQ0kJO3Jkv-S1RukEE,8788
+ragaai_catalyst/tracers/agentic_tracing/tracers/user_interaction_tracer.py,sha256=wsCwTK7tM_L3mdNrcg5Mq3D1k07XCHZkhOB26kz_rLY,1472
+ragaai_catalyst/tracers/agentic_tracing/upload/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ragaai_catalyst/tracers/agentic_tracing/upload/upload_agentic_traces.py,sha256=2Ab8odZXMpYFTh8a7tO53qx9RptF-xxyfgtFN0A6GzI,7690
+ragaai_catalyst/tracers/agentic_tracing/upload/upload_code.py,sha256=u9bRWcM5oDezJupEQoHUXrKz7YvZJK9IZf10ejBWoa4,4254
+ragaai_catalyst/tracers/agentic_tracing/utils/__init__.py,sha256=XdB3X_ufe4RVvGorxSqAiB9dYv4UD7Hvvuw3bsDUppY,60
+ragaai_catalyst/tracers/agentic_tracing/utils/api_utils.py,sha256=JyNCbfpW-w4O9CjtemTqmor2Rh1WGpQwhRaDSRmBxw8,689
+ragaai_catalyst/tracers/agentic_tracing/utils/file_name_tracker.py,sha256=515NNDQJTyy3O-2rdlUYUoWL9qSwLIfvV3sMB9BtHp8,1366
+ragaai_catalyst/tracers/agentic_tracing/utils/generic.py,sha256=WwXT01xmp8MSr7KinuDCSK9a1ifpLcT7ajFkvYviG_A,1190
+ragaai_catalyst/tracers/agentic_tracing/utils/llm_utils.py,sha256=7r9UrXEdftoMWsE0fy0ps9dcPq0o5M4pMYmr7VXs7yc,12238
+ragaai_catalyst/tracers/agentic_tracing/utils/model_costs.json,sha256=6wnDtkBH-uwJeZm9FtyeXuUWux8u-skT3lmrtFwsReI,286298
+ragaai_catalyst/tracers/agentic_tracing/utils/trace_utils.py,sha256=9cFzfFqIA968bUG7LNTjdN7zbdEXUtcvRKg883ade2c,2586
+ragaai_catalyst/tracers/agentic_tracing/utils/unique_decorator.py,sha256=DQHjcEuqEKsNSWaNs7SoOaq50yK4Jsl966S7mBnV-zA,5723
+ragaai_catalyst/tracers/agentic_tracing/utils/zip_list_of_unique_files.py,sha256=faFat_OAUnVJGnauMVo6yeHhTv-_njgyXGOtUwYJ8kE,7568
+ragaai_catalyst/tracers/exporters/__init__.py,sha256=kVA8zp05h3phu4e-iHSlnznp_PzMRczB7LphSsZgUjg,138
+ragaai_catalyst/tracers/exporters/file_span_exporter.py,sha256=RgGteu-NVGprXKkynvyIO5yOjpbtA41R3W_NzCjnkwE,6445
+ragaai_catalyst/tracers/exporters/raga_exporter.py,sha256=pU9EH6Fn1Z757bpM3VaXPDHuJ5wyUrMObGaACiztvTU,18014
+ragaai_catalyst/tracers/instrumentators/__init__.py,sha256=FgnMQupoRTzmVsG9YKsLQera2Pfs-AluZv8CxwavoyQ,253
+ragaai_catalyst/tracers/instrumentators/langchain.py,sha256=yMN0qVF0pUVk6R5M1vJoUXezDo1ejs4klCFRlE8x4vE,574
+ragaai_catalyst/tracers/instrumentators/llamaindex.py,sha256=SMrRlR4xM7k9HK43hakE8rkrWHxMlmtmWD-AX6TeByc,416
+ragaai_catalyst/tracers/instrumentators/openai.py,sha256=14R4KW9wQCR1xysLfsP_nxS7cqXrTPoD8En4MBAaZUU,379
+ragaai_catalyst/tracers/utils/__init__.py,sha256=KeMaZtYaTojilpLv65qH08QmpYclfpacDA0U3wg6Ybw,64
+ragaai_catalyst/tracers/utils/utils.py,sha256=ViygfJ7vZ7U0CTSA1lbxVloHp4NSlmfDzBRNCJuMhis,2374
+ragaai_catalyst-2.1.1.dist-info/METADATA,sha256=PCjCVaeopFVu1f-SysTFHlQn0HYdDI5sI155hCXeHic,1802
+ragaai_catalyst-2.1.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ragaai_catalyst-2.1.1.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.1.1.dist-info/RECORD,,

{ragaai_catalyst-2.1b5.dist-info → ragaai_catalyst-2.1.1.dist-info}/WHEEL

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

ragaai_catalyst/tracers/agentic_tracing/utils/data_classes.py

@@ -1,61 +0,0 @@
-from dataclasses import dataclass, field
-from typing import Dict, List, Any, Optional
-
-
-@dataclass
-class ProjectInfo:
-    project_name: str
-    start_time: float
-    end_time: float = field(default=0)
-    duration: float = field(default=0)
-    total_cost: float = field(default=0)
-    total_tokens: int = field(default=0)
-
-
-@dataclass
-class SystemInfo:
-    project_id: int
-    os_name: str
-    os_version: str
-    python_version: str
-    cpu_info: str
-    memory_total: float
-    installed_packages: str
-
-
-@dataclass
-class LLMCall:
-    name: str
-    model_name: str
-    input_prompt: str
-    output_response: str
-    tool_call: Dict
-    token_usage: Dict[str, int]
-    cost: Dict[str, float]
-    start_time: float = field(default=0)
-    end_time: float = field(default=0)
-    duration: float = field(default=0)
-
-
-@dataclass
-class ToolCall:
-    name: str
-    input_parameters: Dict[str, Any]
-    output: Any
-    start_time: float
-    end_time: float
-    duration: float
-    errors: Optional[str] = None
-
-
-@dataclass
-class AgentCall:
-    name: str
-    input_parameters: Dict[str, Any]
-    output: Any
-    start_time: float
-    end_time: float
-    duration: float
-    tool_calls: List[Dict[str, Any]]
-    llm_calls: List[Dict[str, Any]]
-    errors: Optional[str] = None