ragaai-catalyst 2.0.7.2__py3-none-any.whl → 2.0.7.2b0__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/tool_tracer.py

@@ -0,0 +1,235 @@
+import functools
+import uuid
+from datetime import datetime
+import psutil
+from typing import Optional, Any, Dict, List
+from .unique_decorator import mydecorator
+import contextvars
+import asyncio
+
+class ToolTracerMixin:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.current_tool_name = contextvars.ContextVar("tool_name", default=None)
+        self.current_tool_id = contextvars.ContextVar("tool_id", default=None)
+        self.component_network_calls = {}
+        self._trace_sync_tool_execution = mydecorator(self._trace_sync_tool_execution)
+        self._trace_tool_execution = mydecorator(self._trace_tool_execution)
+
+
+    def trace_tool(self, name: str, tool_type: str = "generic", version: str = "1.0.0"):
+        def decorator(func):
+            # Check if the function is async
+            is_async = asyncio.iscoroutinefunction(func)
+
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                return await self._trace_tool_execution(
+                    func, name, tool_type, version, *args, **kwargs
+                )
+
+            @functools.wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                return self._trace_sync_tool_execution(
+                    func, name, tool_type, version, *args, **kwargs
+                )
+
+            return async_wrapper if is_async else sync_wrapper
+
+        return decorator
+
+    def _trace_sync_tool_execution(self, func, name, tool_type, version, *args, **kwargs):
+        """Synchronous version of tool tracing"""
+        if not self.is_active:
+            return func(*args, **kwargs)
+
+        start_time = datetime.now().astimezone()
+        start_memory = psutil.Process().memory_info().rss
+        component_id = str(uuid.uuid4())
+        hash_id = self._trace_sync_tool_execution.hash_id
+
+        # Start tracking network calls for this component
+        self.start_component(component_id)
+
+        try:
+            # Execute the tool
+            result = func(*args, **kwargs)
+
+            # Calculate resource usage
+            end_time = datetime.now().astimezone()
+            end_memory = psutil.Process().memory_info().rss
+            memory_used = max(0, end_memory - start_memory)
+
+            # End tracking network calls for this component
+            self.end_component(component_id)
+
+            # Create tool component
+            tool_component = self.create_tool_component(
+                component_id=component_id,
+                hash_id=hash_id,
+                name=name,
+                tool_type=tool_type,
+                version=version,
+                memory_used=memory_used,
+                start_time=start_time,
+                end_time=end_time,
+                input_data=self._sanitize_input(args, kwargs),
+                output_data=self._sanitize_output(result)
+            )
+
+            self.add_component(tool_component)
+            return result
+
+        except Exception as e:
+            error_component = {
+                "code": 500,
+                "type": type(e).__name__,
+                "message": str(e),
+                "details": {}
+            }
+            
+            # End tracking network calls for this component
+            self.end_component(component_id)
+            
+            end_time = datetime.now().astimezone()
+            
+            tool_component = self.create_tool_component(
+                component_id=component_id,
+                hash_id=hash_id,
+                name=name,
+                tool_type=tool_type,
+                version=version,
+                memory_used=0,
+                start_time=start_time,
+                end_time=end_time,
+                input_data=self._sanitize_input(args, kwargs),
+                output_data=None,
+                error=error_component
+            )
+
+            self.add_component(tool_component)
+            raise
+
+    async def _trace_tool_execution(self, func, name, tool_type, version, *args, **kwargs):
+        """Asynchronous version of tool tracing"""
+        if not self.is_active:
+            return await func(*args, **kwargs)
+
+        start_time = datetime.now().astimezone()
+        start_memory = psutil.Process().memory_info().rss
+        component_id = str(uuid.uuid4())
+        hash_id = self._trace_tool_execution.hash_id
+
+        try:
+            # Execute the tool
+            result = await func(*args, **kwargs)
+
+            # Calculate resource usage
+            end_time = datetime.now().astimezone()
+            end_memory = psutil.Process().memory_info().rss
+            memory_used = max(0, end_memory - start_memory)
+
+            # Create tool component
+            tool_component = self.create_tool_component(
+                component_id=component_id,
+                hash_id=hash_id,
+                name=name,
+                tool_type=tool_type,
+                version=version,
+                start_time=start_time,
+                end_time=end_time,
+                memory_used=memory_used,
+                input_data=self._sanitize_input(args, kwargs),
+                output_data=self._sanitize_output(result)
+            )
+
+            self.add_component(tool_component)
+            return result
+
+        except Exception as e:
+            error_component = {
+                "code": 500,
+                "type": type(e).__name__,
+                "message": str(e),
+                "details": {}
+            }
+            
+            end_time = datetime.now().astimezone()
+            
+            tool_component = self.create_tool_component(
+                component_id=component_id,
+                hash_id=hash_id,
+                name=name,
+                tool_type=tool_type,
+                version=version,
+                start_time=start_time,
+                end_time=end_time,
+                memory_used=0,
+                input_data=self._sanitize_input(args, kwargs),
+                output_data=None,
+                error=error_component
+            )
+
+            self.add_component(tool_component)
+            raise
+
+    def create_tool_component(self, **kwargs):
+        """Create a tool component according to the data structure"""
+        start_time = kwargs["start_time"]
+        component = {
+            "id": kwargs["component_id"],
+            "hash_id": kwargs["hash_id"],
+            "source_hash_id": None,
+            "type": "tool",
+            "name": kwargs["name"],
+            "start_time": start_time.isoformat(),
+            "end_time": kwargs["end_time"].isoformat(),
+            "error": kwargs.get("error"),
+            "parent_id": self.current_agent_id.get(),
+            "info": {
+                "tool_type": kwargs["tool_type"],
+                "version": kwargs["version"],
+                "memory_used": kwargs["memory_used"]
+            },
+            "data": {
+                "input": kwargs["input_data"],
+                "output": kwargs["output_data"],
+                "memory_used": kwargs["memory_used"]
+            },
+            "network_calls": self.component_network_calls.get(kwargs["component_id"], []),
+            "interactions": [{
+                "id": f"int_{uuid.uuid4()}",
+                "interaction_type": "input",
+                "timestamp": start_time.isoformat(),
+                "content": kwargs["input_data"]
+            }, {
+                "id": f"int_{uuid.uuid4()}",
+                "interaction_type": "output",
+                "timestamp": kwargs["end_time"].isoformat(),
+                "content": kwargs["output_data"]
+            }]
+        }
+
+        return component
+
+    def start_component(self, component_id):
+        self.component_network_calls[component_id] = []
+
+    def end_component(self, component_id):
+        pass
+
+    def _sanitize_input(self, args: tuple, kwargs: dict) -> Dict:
+        """Sanitize and format input data"""
+        return {
+            "args": [str(arg) if not isinstance(arg, (int, float, bool, str, list, dict)) else arg for arg in args],
+            "kwargs": {
+                k: str(v) if not isinstance(v, (int, float, bool, str, list, dict)) else v 
+                for k, v in kwargs.items()
+            }
+        }
+
+    def _sanitize_output(self, output: Any) -> Any:
+        """Sanitize and format output data"""
+        if isinstance(output, (int, float, bool, str, list, dict)):
+            return output
+        return str(output)

ragaai_catalyst/tracers/agentic_tracing/unique_decorator.py

@@ -0,0 +1,221 @@
+import hashlib
+import inspect
+import functools
+import re
+import tokenize
+import io
+import uuid
+
+def normalize_source_code(source):
+    """
+    Advanced normalization of source code that:
+    1. Preserves docstrings
+    2. Removes comments
+    3. Removes extra whitespace
+    
+    Args:
+        source (str): Original source code
+    
+    Returns:
+        str: Normalized source code
+    """
+    # Use tokenize to carefully parse the source code
+    normalized_tokens = []
+    
+    try:
+        # Convert source to a file-like object for tokenize
+        token_source = io.StringIO(source).readline
+        
+        for token_type, token_string, _, _, _ in tokenize.generate_tokens(token_source):
+            # Preserve strings (including docstrings)
+            if token_type == tokenize.STRING:
+                normalized_tokens.append(token_string.strip())
+            
+            # Preserve code tokens
+            elif token_type in [
+                tokenize.NAME, 
+                tokenize.NUMBER, 
+                tokenize.OP
+            ]:
+                normalized_tokens.append(token_string.strip())
+    
+    except tokenize.TokenError:
+        # Fallback to a simpler method if tokenization fails
+        normalized_tokens = re.findall(r'\w+|[^\w\s]', source)
+    
+    # Remove extra spaces and join
+    normalized_source = ''.join(normalized_tokens)
+    
+    return normalized_source
+
+# def generate_unique_hash(obj, *call_args, **call_kwargs):
+#     print('#'*100,'hash id: ', '#'*100)
+#     print(obj)
+#     print(*call_args)
+#     # print(**call_kwargs)
+#     """
+#     Generate a unique, deterministic hash for a given object.
+    
+#     Args:
+#         obj: The object (function or class) to generate hash for
+#         additional_salt: Optional additional salt to ensure uniqueness
+    
+#     Returns:
+#         str: A unique hash_id meeting the specified requirements
+#     """
+#     # Handle different object types
+
+#     if inspect.isclass(obj):
+#         # For classes, use the class definition
+#         try:
+#             source = inspect.getsource(obj)
+#         except (IOError, TypeError):
+#             source = repr(obj)
+        
+#         # Use class name in hash generation
+#         hash_input = f"{obj.__name__}{normalize_source_code(source)}"
+    
+#     else:
+#         # For functions and methods
+#         # Get full signature information
+#         signature = inspect.signature(obj)
+        
+#         # Capture parameter names and their default values
+#         params_info = []
+#         for name, param in signature.parameters.items():
+#             param_str = f"{name}:{param.kind}"
+#             if param.default != inspect.Parameter.empty:
+#                 param_str += f":default={param.default}"
+#             params_info.append(param_str)
+        
+#         # Get source code
+#         try:
+#             source = inspect.getsource(obj)
+#         except (IOError, TypeError):
+#             source = repr(obj)
+        
+#         # Combine method name, parameters, and normalized source
+#         hash_input = (
+#             f"{obj.__name__}"  # Method name
+#             f"{''.join(params_info)}"  # Parameter details
+#             f"{normalize_source_code(source)}"  # Normalized source code
+#         )
+    
+#     # Add optional salt
+#         args_repr = str(call_args) + str(sorted(call_kwargs.items()))
+#         hash_input += args_repr    
+#     # Use SHA-256 for generating the hash
+#     hash_object = hashlib.sha256(hash_input.encode('utf-8'))
+    
+#     # Generate hash and truncate to 32 characters
+#     hash_id = hash_object.hexdigest()[:32]
+    
+#     # Ensure the hash starts with a letter
+#     if not hash_id[0].isalpha():
+#         hash_id = 'a' + hash_id[1:]
+    
+#     print(hash_id)
+#     return hash_id
+
+
+
+def generate_unique_hash(obj, *args, **kwargs):
+    """Generate a unique hash based on the normalized function definition and its arguments"""
+    if inspect.ismethod(obj) or inspect.isfunction(obj):
+        # Get function name and source code
+        func_name = obj.__name__
+        try:
+            # Get the source code and normalize it
+            func_source = inspect.getsource(obj)
+            normalized_source = normalize_source_code(func_source)
+        except (IOError, TypeError):
+            normalized_source = ""
+        
+        # Get function arguments
+        if args and hasattr(args[0], '__class__'):
+            # If it's a method, skip the 'self' argument
+            args = args[1:]
+        
+        # Normalize argument values
+        def normalize_arg(arg):
+            if isinstance(arg, (str, int, float, bool)):
+                return str(arg)
+            elif isinstance(arg, (list, tuple, set)):
+                return '_'.join(normalize_arg(x) for x in arg)
+            elif isinstance(arg, dict):
+                return '_'.join(f"{normalize_arg(k)}:{normalize_arg(v)}" 
+                              for k, v in sorted(arg.items()))
+            elif callable(arg):
+                return arg.__name__
+            else:
+                return str(type(arg).__name__)
+
+        # Create normalized strings of arguments
+        args_str = '_'.join(normalize_arg(arg) for arg in args)
+        kwargs_str = '_'.join(f"{k}:{normalize_arg(v)}" 
+                            for k, v in sorted(kwargs.items()))
+        
+        # Combine all components
+        hash_input = f"{func_name}_{normalized_source}_{args_str}_{kwargs_str}"
+    
+    elif inspect.isclass(obj):
+        # For classes, normalize the class definition
+        try:
+            class_source = inspect.getsource(obj)
+            normalized_source = normalize_source_code(class_source)
+            hash_input = f"{obj.__name__}_{normalized_source}"
+        except (IOError, TypeError):
+            hash_input = f"{obj.__name__}_{str(obj)}"
+    
+    else:
+        # For other objects, use their string representation
+        hash_input = str(obj)
+
+    # Create hash
+    hash_obj = hashlib.md5(hash_input.encode('utf-8'))
+    return hash_obj.hexdigest()
+
+
+class UniqueIdentifier:
+    _instance = None
+    _hash_cache = {}  # Class-level cache for storing hashes
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, salt=None):
+        # Initialize only once
+        if not hasattr(self, 'salt'):
+            self.salt = salt
+
+    def __call__(self, obj):
+        if inspect.isclass(obj):
+            hash_id = generate_unique_hash(obj)
+            setattr(obj, 'hash_id', hash_id)
+            return obj
+        
+        @functools.wraps(obj)
+        def wrapper(*args, **kwargs):
+            # Generate cache key based on function and arguments
+            cache_key = (obj.__name__, str(args), str(kwargs))
+            
+            # Use cached hash if available, otherwise generate new one
+            if cache_key not in self._hash_cache:
+                self._hash_cache[cache_key] = generate_unique_hash(obj, *args, **kwargs)
+            
+            # Store hash_id on the wrapper function
+            wrapper.hash_id = self._hash_cache[cache_key]
+            
+            return obj(*args, **kwargs)
+        
+        # Initialize hash_id
+        initial_hash = generate_unique_hash(obj)
+        wrapper.hash_id = initial_hash
+        
+        return wrapper
+
+# Create a single instance to be used across all mixins
+mydecorator = UniqueIdentifier()
+

ragaai_catalyst/tracers/agentic_tracing/unique_decorator_test.py

@@ -0,0 +1,172 @@
+from unique_decorator import mydecorator
+from unique_decorator import generate_unique_hash
+import inspect
+
+def print_test_case(case_num, description, expected_behavior, hash1, hash2=None):
+    print(f"\n{'='*100}")
+    print(f"Test Case #{case_num}: {description}")
+    print(f"Expected Behavior: {expected_behavior}")
+    print(f"{'='*100}")
+    if hash2 is not None:
+        print(f"Hash ID 1: {hash1}")
+        print(f"Hash ID 2: {hash2}")
+        print(f"Hash IDs are {'EQUAL' if hash1 == hash2 else 'DIFFERENT'} (Expected: {expected_behavior})")
+    else:
+        print(f"Hash ID: {hash1}")
+    print(f"{'='*100}\n")
+
+# Test Case 1: Same function with different formatting
+# Expected: Same hash_id
+@mydecorator
+def example_function():
+    x = 1
+    return x
+
+hash1 = example_function.hash_id
+
+@mydecorator
+def example_function():
+    # This is a comment
+    x     =      1  # Another comment
+    return     x    # More spacing
+
+hash2 = example_function.hash_id
+
+print_test_case(1, 
+                "Same function with different formatting and comments", 
+                "Hash IDs should be EQUAL",
+                hash1, hash2)
+
+# Test Case 2: Function with parameters - different argument orders
+# Expected: Same hash_id for same arguments in different order
+@mydecorator
+def function_with_params(a: int, b: int = 10):
+    return a + b
+
+result1 = function_with_params(a=2, b=3)
+hash1 = function_with_params.hash_id
+
+result2 = function_with_params(b=3, a=2)
+hash2 = function_with_params.hash_id
+
+print_test_case(2, 
+                "Same function call with different argument order (a=2, b=3 vs b=3, a=2)", 
+                "Hash IDs should be EQUAL",
+                hash1, hash2)
+
+# Test Case 3: Function with different default value
+# Expected: Different hash_id
+@mydecorator
+def function_with_params(a: int, b: int = 5):  # Different default value
+    return a + b
+
+hash3 = function_with_params.hash_id
+
+print_test_case(3, 
+                "Same function name but different default parameter value", 
+                "Hash IDs should be DIFFERENT",
+                hash2, hash3)
+
+# Test Case 4: Class methods with different formatting
+# Expected: Same hash_id
+@mydecorator
+class ExampleClass:
+    @mydecorator
+    def method1(self):
+        x = 1
+        return x
+
+hash1 = ExampleClass().method1.hash_id
+
+@mydecorator
+class ExampleClass:
+    @mydecorator
+    def method1(self):
+        # Comment here
+        x    =    1
+        return    x
+
+hash2 = ExampleClass().method1.hash_id
+
+print_test_case(4, 
+                "Class method with different formatting", 
+                "Hash IDs should be EQUAL",
+                hash1, hash2)
+
+# Test Case 5: Functions with different argument types but same content
+# Expected: Same hash_id
+@mydecorator
+def complex_function(a: dict, b: list = [1, 2]):
+    return a, b
+
+test_dict1 = {"a": 1, "b": 2}
+test_dict2 = {"b": 2, "a": 1}  # Same content, different order
+test_list1 = [1, 2, 3]
+test_list2 = [1, 2, 3]  # Identical list
+
+result1 = complex_function(test_dict1, test_list1)
+hash1 = complex_function.hash_id
+
+result2 = complex_function(test_dict2, test_list2)
+hash2 = complex_function.hash_id
+
+print_test_case(5, 
+                "Complex function with same content in different order", 
+                "Hash IDs should be EQUAL",
+                hash1, hash2)
+
+# Test Case 6: Function with docstring - different formatting
+# Expected: Same hash_id
+@mydecorator
+def documented_function(x: int):
+    """
+    This is a docstring.
+    It should be preserved in the hash.
+    """
+    # This is a comment that should be ignored
+    return x * 2  # This comment should also be ignored
+
+hash1 = documented_function.hash_id
+
+@mydecorator
+def documented_function(x:int):
+    """
+    This is a docstring.
+    It should be preserved in the hash.
+    """
+    return x*2
+
+hash2 = documented_function.hash_id
+
+print_test_case(6, 
+                "Function with docstring - different formatting", 
+                "Hash IDs should be EQUAL",
+                hash1, hash2)
+
+# Test Case 7: Different functions with same structure
+# Expected: Different hash_id
+@mydecorator
+def function_a(x):
+    return x + 1
+
+@mydecorator
+def function_b(x):
+    return x + 1
+
+print_test_case(7, 
+                "Different function names with same implementation", 
+                "Hash IDs should be DIFFERENT",
+                function_a.hash_id, function_b.hash_id)
+
+# Test Case 8: Same function with different argument values
+# Expected: Different hash_id
+result1 = function_with_params(a=1, b=2)
+hash1 = function_with_params.hash_id
+
+result2 = function_with_params(a=3, b=4)
+hash2 = function_with_params.hash_id
+
+print_test_case(8, 
+                "Same function with different argument values", 
+                "Hash IDs should be DIFFERENT",
+                hash1, hash2)

ragaai_catalyst/tracers/agentic_tracing/user_interaction_tracer.py

@@ -0,0 +1,67 @@
+import builtins
+from contextlib import contextmanager, asynccontextmanager
+from datetime import datetime
+
+from ..data import UserInteractionModel
+
+
+class UserInteractionTracer:
+    def __init__(self, tracer):
+        self.tracer = tracer
+        self.original_input = builtins.input
+        self.original_print = builtins.print
+
+    def input(self, prompt=""):
+        content = prompt
+        user_input = self.original_input(prompt)
+        self._log_interaction("input", user_input)
+        return user_input
+
+    def print(self, *args, **kwargs):
+        content = " ".join(str(arg) for arg in args)
+        self._log_interaction("output", content)
+        self.original_print(*args, **kwargs)
+
+    def _log_interaction(self, interaction_type, content):
+        agent_id = self.tracer.current_agent_id.get()
+        user_interaction = UserInteractionModel(
+            project_id=self.tracer.project_id,
+            trace_id=self.tracer.trace_id,
+            agent_id=agent_id,
+            interaction_type=interaction_type,
+            content=content,
+            timestamp=datetime.now(),
+        )
+        with self.tracer.Session() as session:
+            session.add(user_interaction)
+            session.commit()
+
+        # Also add to trace data
+        self.tracer.trace_data.setdefault("user_interactions", []).append(
+            {
+                "interaction_type": interaction_type,
+                "content": content,
+                "timestamp": datetime.now(),
+                "agent_id": agent_id,
+            }
+        )
+
+    @contextmanager
+    def capture(self):
+        builtins.input = self.input
+        builtins.print = self.print
+        try:
+            yield
+        finally:
+            builtins.input = self.original_input
+            builtins.print = self.original_print
+
+    @asynccontextmanager
+    async def async_capture(self):
+        builtins.input = self.input
+        builtins.print = self.print
+        try:
+            yield
+        finally:
+            builtins.input = self.original_input
+            builtins.print = self.original_print

ragaai_catalyst/tracers/agentic_tracing/utils/__init__.py

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