ragaai-catalyst 2.0.7.2b1__py3-none-any.whl → 2.1b1__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/tool_tracer.py

@@ -3,38 +3,57 @@ import uuid
 from datetime import datetime
 import psutil
 from typing import Optional, Any, Dict, List
-from .unique_decorator import mydecorator
+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._trace_sync_tool_execution = mydecorator(self._trace_sync_tool_execution)
-        self._trace_tool_execution = mydecorator(self._trace_tool_execution)
+        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
                 )
 
-            return async_wrapper if is_async else sync_wrapper
+            wrapper = async_wrapper if is_async else sync_wrapper
+            wrapper.metadata = metadata
+            return wrapper
 
         return decorator
 
@@ -46,7 +65,7 @@ class ToolTracerMixin:
         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
+        hash_id = generate_unique_hash_simple(func)
 
         # Start tracking network calls for this component
         self.start_component(component_id)
@@ -118,7 +137,7 @@ class ToolTracerMixin:
         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
+        hash_id = generate_unique_hash_simple(func)
 
         try:
             # Execute the tool
@@ -142,7 +161,6 @@ class ToolTracerMixin:
                 input_data=self._sanitize_input(args, kwargs),
                 output_data=self._sanitize_output(result)
             )
-
             self.add_component(tool_component)
             return result
 
@@ -169,11 +187,12 @@ class ToolTracerMixin:
                 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 = {
@@ -197,19 +216,12 @@ class ToolTracerMixin:
                 "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"]
-            }]
+            "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):

ragaai_catalyst/tracers/agentic_tracing/unique_decorator.py

@@ -4,7 +4,7 @@ import functools
 import re
 import tokenize
 import io
-import uuid
+import types
 
 def normalize_source_code(source):
     """
@@ -19,123 +19,33 @@ def normalize_source_code(source):
     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
-            ]:
+            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
-
+    return ''.join(normalized_tokens)
 
-
-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):
+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 = obj.__name__
+        func_name = func.__name__
         try:
-            # Get the source code and normalize it
-            func_source = inspect.getsource(obj)
+            func_source = inspect.getsource(func)
             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)):
@@ -158,27 +68,62 @@ def generate_unique_hash(obj, *args, **kwargs):
         # Combine all components
         hash_input = f"{func_name}_{normalized_source}_{args_str}_{kwargs_str}"
     
-    elif inspect.isclass(obj):
-        # For classes, normalize the class definition
+    elif inspect.isclass(func):
         try:
-            class_source = inspect.getsource(obj)
+            class_source = inspect.getsource(func)
             normalized_source = normalize_source_code(class_source)
-            hash_input = f"{obj.__name__}_{normalized_source}"
+            hash_input = f"{func.__name__}_{normalized_source}"
         except (IOError, TypeError):
-            hash_input = f"{obj.__name__}_{str(obj)}"
+            hash_input = f"{func.__name__}_{str(func)}"
     
     else:
-        # For other objects, use their string representation
-        hash_input = str(obj)
+        hash_input = str(func)
 
-    # Create hash
     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 = {}  # Class-level cache for storing hashes
+    _hash_cache = {}
 
     def __new__(cls, *args, **kwargs):
         if cls._instance is None:
@@ -186,7 +131,6 @@ class UniqueIdentifier:
         return cls._instance
 
     def __init__(self, salt=None):
-        # Initialize only once
         if not hasattr(self, 'salt'):
             self.salt = salt
 
@@ -198,15 +142,16 @@ class UniqueIdentifier:
         
         @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)
+            # 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 = self._hash_cache[cache_key]
+            wrapper.hash_id = hash_id
             
             return obj(*args, **kwargs)
         
@@ -217,5 +162,4 @@ class UniqueIdentifier:
         return wrapper
 
 # Create a single instance to be used across all mixins
-mydecorator = UniqueIdentifier()
-
+mydecorator = UniqueIdentifier()

ragaai_catalyst/tracers/agentic_tracing/upload_agentic_traces.py

@@ -0,0 +1,187 @@
+import requests
+import json
+import os
+from datetime import datetime
+
+
+class UploadAgenticTraces:
+    def __init__(self, 
+                 json_file_path,
+                 project_name,
+                 project_id,
+                 dataset_name,
+                 user_detail,
+                 base_url):
+        self.json_file_path = json_file_path
+        self.project_name = project_name
+        self.project_id = project_id
+        self.dataset_name = dataset_name
+        self.user_detail = user_detail
+        self.base_url = base_url
+        self.timeout = 99999
+
+    def _create_dataset_schema_with_trace(self):
+        SCHEMA_MAPPING_NEW = {
+            "trace_id": {"columnType": "traceId"},
+            "trace_uri": {"columnType": "traceUri"},
+            "prompt": {"columnType": "prompt"},
+            "response":{"columnType": "response"},
+            "context": {"columnType": "context"},
+            "llm_model": {"columnType":"pipeline"},
+            "recorded_on": {"columnType": "metadata"},
+            "embed_model": {"columnType":"pipeline"},
+            "log_source": {"columnType": "metadata"},
+            "vector_store":{"columnType":"pipeline"},
+            "feedback": {"columnType":"feedBack"}
+        }
+        def make_request():
+            headers = {
+                "Content-Type": "application/json",
+                "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "X-Project-Name": self.project_name,
+            }
+            payload = json.dumps({
+                "datasetName": self.dataset_name,
+                # "schemaMapping": SCHEMA_MAPPING_NEW,
+                "traceFolderUrl": None,
+            })
+            response = requests.request("POST",
+                f"{self.base_url}/v1/llm/dataset/logs",
+                headers=headers,
+                data=payload,
+                timeout=self.timeout
+            )
+
+            return response
+
+        response = make_request()
+
+        if response.status_code == 401:
+            # get_token()  # Fetch a new token and set it in the environment
+            response = make_request()  # Retry the request
+        if response.status_code != 200:
+            return response.status_code
+        return response.status_code
+
+
+    def _get_presigned_url(self):
+        payload = json.dumps({
+                "datasetName": self.dataset_name,
+                "numFiles": 1,
+            })
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+            "X-Project-Name": self.project_name,
+        }
+
+        try:
+            response = requests.request("GET", 
+                                        f"{self.base_url}/v1/llm/presigned-url", 
+                                        headers=headers, 
+                                        data=payload,
+                                        timeout=self.timeout)
+            if response.status_code == 200:
+                presignedUrls = response.json()["data"]["presignedUrls"][0]
+                return presignedUrls
+        except requests.exceptions.RequestException as e:
+            print(f"Error while getting presigned url: {e}")
+            return None
+
+    def _put_presigned_url(self, presignedUrl, filename):
+        headers = {
+                "Content-Type": "application/json",
+            }
+
+        if "blob.core.windows.net" in presignedUrl:  # Azure
+            headers["x-ms-blob-type"] = "BlockBlob"
+        print(f"Uploading agentic traces...")
+        try:
+            with open(filename) as f:
+                payload = f.read().replace("\n", "").replace("\r", "").encode()
+        except Exception as e:
+            print(f"Error while reading file: {e}")
+            return None
+        try:
+            response = requests.request("PUT", 
+                                        presignedUrl, 
+                                        headers=headers, 
+                                        data=payload,
+                                        timeout=self.timeout)
+            if response.status_code != 200 or response.status_code != 201:
+                return response, response.status_code
+        except requests.exceptions.RequestException as e:
+            print(f"Error while uploading to presigned url: {e}")
+            return None
+
+    def insert_traces(self, presignedUrl):
+        headers = {
+                "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+                "Content-Type": "application/json",
+                "X-Project-Name": self.project_name,
+            }
+        payload = json.dumps({
+                "datasetName": self.dataset_name,
+                "presignedUrl": presignedUrl,
+                "datasetSpans": self._get_dataset_spans(), #Extra key for agentic traces
+            })
+        try:
+            response = requests.request("POST", 
+                                        f"{self.base_url}/v1/llm/insert/trace", 
+                                        headers=headers, 
+                                        data=payload,
+                                        timeout=self.timeout)
+        except requests.exceptions.RequestException as e:
+            print(f"Error while inserting traces: {e}")
+            return None
+
+    def _get_dataset_spans(self):
+        try:
+            with open(self.json_file_path) as f:
+                data = json.load(f)
+        except Exception as e:
+            print(f"Error while reading file: {e}")
+            return None
+        try:
+            spans = data["data"][0]["spans"]
+            datasetSpans = []
+            for span in spans:
+                if span["type"] != "agent":
+                    existing_span = next((s for s in datasetSpans if s["spanHash"] == span["hash_id"]), None)
+                    if existing_span is None:
+                        datasetSpans.append({
+                            "spanId": span["id"],
+                            "spanName": span["name"],
+                            "spanHash": span["hash_id"],
+                            "spanType": span["type"],
+                        })
+                else:
+                    datasetSpans.append({
+                                "spanId": span["id"],
+                                "spanName": span["name"],
+                                "spanHash": span["hash_id"],
+                                "spanType": span["type"],
+                            })
+                    children = span["data"]["children"]
+                    for child in children:
+                        existing_span = next((s for s in datasetSpans if s["spanHash"] == child["hash_id"]), None)
+                        if existing_span is None:
+                            datasetSpans.append({
+                                "spanId": child["id"],
+                                "spanName": child["name"],
+                                "spanHash": child["hash_id"],
+                                "spanType": child["type"],
+                            })
+            return datasetSpans
+        except Exception as e:
+            print(f"Error while reading dataset spans: {e}")
+            return None
+    
+    def upload_agentic_traces(self):
+        self._create_dataset_schema_with_trace()
+        presignedUrl = self._get_presigned_url()
+        if presignedUrl is None:
+            return
+        self._put_presigned_url(presignedUrl, self.json_file_path)
+        self.insert_traces(presignedUrl)
+        print("Agentic Traces uploaded")

ragaai_catalyst/tracers/agentic_tracing/upload_code.py

@@ -0,0 +1,115 @@
+from aiohttp import payload
+import requests
+import json
+import os
+import logging
+logger = logging.getLogger(__name__)
+
+def upload_code(hash_id, zip_path, project_name, dataset_name):
+    code_hashes_list = _fetch_dataset_code_hashes(project_name, dataset_name)
+
+    if hash_id not in code_hashes_list:
+        presigned_url = _fetch_presigned_url(project_name, dataset_name)
+        _put_zip_presigned_url(project_name, presigned_url, zip_path)
+
+        response = _insert_code(dataset_name, hash_id, presigned_url, project_name)
+        return response
+    else:
+        return "Code already exists"
+
+def _fetch_dataset_code_hashes(project_name, dataset_name):
+    payload = {}
+    headers = {
+        "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+        "X-Project-Name": project_name,
+    }
+
+    try:
+        response = requests.request("GET", 
+                                    f"{os.getenv('RAGAAI_CATALYST_BASE_URL')}/v2/llm/dataset/code?datasetName={dataset_name}", 
+                                    headers=headers, 
+                                    data=payload,
+                                    timeout=99999)
+
+        if response.status_code == 200:
+            return response.json()["data"]["codeHashes"]
+        else:
+            raise Exception(f"Failed to fetch code hashes: {response.json()['message']}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to list datasets: {e}")
+        raise 
+
+def _fetch_presigned_url(project_name, dataset_name):
+    payload = json.dumps({
+            "datasetName": dataset_name,
+            "numFiles": 1,
+            "contentType": "application/zip"
+            })
+
+    headers = {
+        "Authorization": f"Bearer {os.getenv('RAGAAI_CATALYST_TOKEN')}",
+        "Content-Type": "application/json",
+        "X-Project-Name": project_name,
+    }
+
+    try:
+        response = requests.request("GET", 
+                                    f"{os.getenv('RAGAAI_CATALYST_BASE_URL')}/v1/llm/presigned-url", 
+                                    headers=headers, 
+                                    data=payload,
+                                    timeout=99999)
+
+        if response.status_code == 200:
+            return response.json()["data"]["presignedUrls"][0]
+        else:
+            raise Exception(f"Failed to fetch code hashes: {response.json()['message']}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to list datasets: {e}")
+        raise
+
+def _put_zip_presigned_url(project_name, presignedUrl, filename):
+    headers = {
+            "X-Project-Name": project_name,
+            "Content-Type": "application/zip",
+        }
+
+    if "blob.core.windows.net" in presignedUrl:  # Azure
+        headers["x-ms-blob-type"] = "BlockBlob"
+    print(f"Uploading code...")
+    with open(filename, 'rb') as f:
+        payload = f.read()
+
+    response = requests.request("PUT", 
+                                presignedUrl, 
+                                headers=headers, 
+                                data=payload,
+                                timeout=99999)
+    if response.status_code != 200 or response.status_code != 201:
+        return response, response.status_code
+
+def _insert_code(dataset_name, hash_id, presigned_url, project_name):
+    payload = json.dumps({
+        "datasetName": dataset_name,
+        "codeHash": hash_id,
+        "presignedUrl": presigned_url
+        })
+    
+    headers = {
+        'X-Project-Name': project_name,
+        'Content-Type': 'application/json',
+        'Authorization': f'Bearer {os.getenv("RAGAAI_CATALYST_TOKEN")}'
+        }
+    
+    try:
+        response = requests.request("POST", 
+                                    f"{os.getenv('RAGAAI_CATALYST_BASE_URL')}/v2/llm/dataset/code", 
+                                    headers=headers, 
+                                    data=payload,
+                                    timeout=99999)
+        if response.status_code == 200:
+            return response.json()["message"]
+        else:
+            raise Exception(f"Failed to insert code: {response.json()['message']}")
+    except requests.exceptions.RequestException as e:
+        logger.error(f"Failed to insert code: {e}")
+        raise