ragaai-catalyst 2.1b0__py3-none-any.whl → 2.1b2__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/tool_tracer.py

@@ -0,0 +1,247 @@
+import functools
+import uuid
+from datetime import datetime
+import psutil
+from typing import Optional, Any, Dict, List
+from .unique_decorator import generate_unique_hash_simple  
+import contextvars
+import asyncio
+from .file_name_tracker import TrackName
+
+
+class ToolTracerMixin:
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.file_tracker = TrackName()
+        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.component_user_interaction = {}
+        self.gt = None
+
+
+    def trace_tool(self, name: str, tool_type: str = "generic", version: str = "1.0.0"):
+        def decorator(func):
+            # Add metadata attribute to the function
+            metadata = {
+                "name": name,
+                "tool_type": tool_type,
+                "version": version,
+                "is_active": True
+            }
+            
+            # Check if the function is async
+            is_async = asyncio.iscoroutinefunction(func)
+
+            @self.file_tracker.trace_decorator
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                async_wrapper.metadata = metadata
+                self.gt = kwargs.get('gt', None) if kwargs else None
+                return await self._trace_tool_execution(
+                    func, name, tool_type, version, *args, **kwargs
+                )
+
+            @self.file_tracker.trace_decorator
+            @functools.wraps(func)
+            def sync_wrapper(*args, **kwargs):
+                sync_wrapper.metadata = metadata
+                self.gt = kwargs.get('gt', None) if kwargs else None
+                return self._trace_sync_tool_execution(
+                    func, name, tool_type, version, *args, **kwargs
+                )
+
+            wrapper = async_wrapper if is_async else sync_wrapper
+            wrapper.metadata = metadata
+            return 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 = generate_unique_hash_simple(func)
+
+        # 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 = generate_unique_hash_simple(func)
+
+        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": self.component_user_interaction.get(kwargs["component_id"], [])
+        }
+
+        if self.gt: 
+            component["data"]["gt"] = self.gt
+
+        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,165 @@
+import hashlib
+import inspect
+import functools
+import re
+import tokenize
+import io
+import types
+
+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
+    """
+    normalized_tokens = []
+    
+    try:
+        token_source = io.StringIO(source).readline
+        
+        for token_type, token_string, _, _, _ in tokenize.generate_tokens(token_source):
+            if token_type == tokenize.STRING:
+                normalized_tokens.append(token_string.strip())
+            elif token_type in [tokenize.NAME, tokenize.NUMBER, tokenize.OP]:
+                normalized_tokens.append(token_string.strip())
+    
+    except tokenize.TokenError:
+        normalized_tokens = re.findall(r'\w+|[^\w\s]', source)
+    
+    return ''.join(normalized_tokens)
+
+def generate_unique_hash(func, *args, **kwargs):
+    """Generate a unique hash based on the original function and its arguments"""
+    if inspect.ismethod(func) or inspect.isfunction(func):
+        # Get function name and source code
+        func_name = func.__name__
+        try:
+            func_source = inspect.getsource(func)
+            normalized_source = normalize_source_code(func_source)
+        except (IOError, TypeError):
+            normalized_source = ""
+        
+        # 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(func):
+        try:
+            class_source = inspect.getsource(func)
+            normalized_source = normalize_source_code(class_source)
+            hash_input = f"{func.__name__}_{normalized_source}"
+        except (IOError, TypeError):
+            hash_input = f"{func.__name__}_{str(func)}"
+    
+    else:
+        hash_input = str(func)
+
+    hash_obj = hashlib.md5(hash_input.encode('utf-8'))
+    return hash_obj.hexdigest()
+
+def generate_unique_hash_simple(func):
+    """Generate a unique hash based on the function name and normalized source code.
+    Works for both standalone functions and class methods (where self would be passed)."""
+    import hashlib
+    import inspect
+    
+    # Handle bound methods (instance methods of classes)
+    if hasattr(func, '__self__'):
+        # Get the underlying function from the bound method
+        func = func.__func__
+    
+
+    # Get function name
+    func_name = func.__name__
+    
+    # Get and normalize source code based on type
+    try:
+        if isinstance(func, (types.FunctionType, types.MethodType)):
+            source = inspect.getsource(func)
+            # Remove whitespace and normalize line endings
+            normalized_source = "\n".join(line.strip() for line in source.splitlines())
+        elif inspect.isclass(func):
+            source = inspect.getsource(func)
+            normalized_source = "\n".join(line.strip() for line in source.splitlines())
+        else:
+            normalized_source = str(func)
+    except (IOError, TypeError):
+        normalized_source = str(func)
+    
+    # Use fixed timestamp for reproducibility
+    timestamp = "2025-01-03T18:15:16+05:30"
+    
+    # Combine components
+    hash_input = f"{func_name}_{normalized_source}_{timestamp}"
+    
+    # Generate MD5 hash
+    hash_obj = hashlib.md5(hash_input.encode('utf-8'))
+    return hash_obj.hexdigest()
+
+class UniqueIdentifier:
+    _instance = None
+    _hash_cache = {}
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self, salt=None):
+        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 hash based on the original function and its arguments
+            if hasattr(args[0], 'original_func'):  # Check if it's a wrapped LLM call
+                original_func = args[0].original_func
+                func_args = args[1:]  # Skip the original_func argument
+                hash_id = generate_unique_hash(original_func, *func_args, **kwargs)
+            else:
+                hash_id = generate_unique_hash(obj, *args, **kwargs)
+            
+            # Store hash_id on the wrapper function
+            wrapper.hash_id = hash_id
+            
+            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)