ragaai-catalyst 2.1.7.1b0__py3-none-any.whl → 2.1.7.2__py3-none-any.whl

ragaai_catalyst/synthetic_data_generation.py

@@ -813,8 +813,9 @@ Irrelevant Examples: Any examples that are not relevant to the user's instructio
                 )
             except Exception as e:
                 continue
-            row_dict['generated_examples'] = examples
-            fin_df_list.append(row_dict)
+            for example in examples:
+                row_dict['generated_examples'] = example
+                fin_df_list.append(row_dict)
         fin_df = pd.DataFrame(fin_df_list)
         csv_file, csv_ext = os.path.splitext(csv_path)
         if not dst_csv_path:
@@ -824,6 +825,7 @@ Irrelevant Examples: Any examples that are not relevant to the user's instructio
             os.makedirs(dst_dir, exist_ok=True)
         fin_df.to_csv(dst_csv_path)
         logger.info(f'CSV with generated examples saved at {dst_csv_path}')
+        return dst_csv_path
 
 
 # Usage:

ragaai_catalyst/tracers/utils/rag_trace_json_converter.py

@@ -14,44 +14,156 @@ logging_level = (
 def rag_trace_json_converter(input_trace, custom_model_cost, trace_id, user_details, tracer_type,user_context):
     trace_aggregate = {}
     def get_prompt(input_trace):
-        if tracer_type == "langchain":
-            for span in input_trace:
-                if span["name"] in ["ChatOpenAI", "ChatAnthropic", "ChatGoogleGenerativeAI"]:
-                    return span["attributes"].get("llm.input_messages.1.message.content")
-
-                elif span["name"] == "LLMChain":
-                    return json.loads(span["attributes"].get("input.value", "{}")).get("question")
+        try:
+            if tracer_type == "langchain":
+                for span in input_trace:
+                    try:
+                        # First check if there's a user message in any of the input messages
+                        attributes = span.get("attributes", {})
+                        
+                        # Look for user role in any of the input messages
+                        if attributes:
+                            for key, value in attributes.items():
+                                try:
+                                    if key.startswith("llm.input_messages.") and key.endswith(".message.role") and value == "user":
+                                        # Extract the message number
+                                        message_num = key.split(".")[2]
+                                        # Construct the content key
+                                        content_key = f"llm.input_messages.{message_num}.message.content"
+                                        if content_key in attributes:
+                                            return attributes.get(content_key)
+                                except Exception as e:
+                                    logger.warning(f"Error processing attribute key-value pair: {str(e)}")
+                                    continue
 
-                elif span["name"] == "RetrievalQA":
-                    return span["attributes"].get("input.value")
+                            for key, value in attributes.items():
+                                try:
+                                    if key.startswith("llm.prompts") and isinstance(value, list):
+                                        human_message = None
+                                        for message in value:
+                                            if isinstance(message, str):
+                                                human_index = message.find("Human:")
+                                                if human_index != -1:
+                                                    human_message = message[human_index:].replace("Human:", "")
+                                                    break
+                                        return human_message if human_message else value
+                                except Exception as e:
+                                    logger.warning(f"Error processing attribute key-value pair for prompt: {str(e)}")
+                                    continue
+                    except Exception as e:
+                        logger.warning(f"Error processing span for prompt extraction: {str(e)}")
+                        continue
                 
-                elif span["name"] == "VectorStoreRetriever":
-                    return span["attributes"].get("input.value")
+                for span in input_trace:
+                    try:
+                        # If no user message found, check for specific span types
+                        if span["name"] == "LLMChain":
+                            try:
+                                input_value = span["attributes"].get("input.value", "{}")
+                                return json.loads(input_value).get("question", "")
+                            except json.JSONDecodeError:
+                                logger.warning(f"Invalid JSON in LLMChain input.value: {input_value}")
+                                continue
+                        elif span["name"] == "RetrievalQA":
+                            return span["attributes"].get("input.value", "")
+                        elif span["name"] == "VectorStoreRetriever":
+                            return span["attributes"].get("input.value", "")
+                    except Exception as e:
+                        logger.warning(f"Error processing span for fallback prompt extraction: {str(e)}")
+                        continue
                 
-        return None
+                # If we've gone through all spans and found nothing
+                logger.warning("No user message found in any span")
+                logger.warning("Returning empty string for prompt.")
+                return ""
+            
+            logger.error("Prompt not found in the trace")
+            return None
+        except Exception as e:
+            logger.error(f"Error while extracting prompt from trace: {str(e)}")
+            return None
     
     def get_response(input_trace):
-        if tracer_type == "langchain":
-            for span in input_trace:
-                if span["name"] in ["ChatOpenAI", "ChatAnthropic", "ChatGoogleGenerativeAI"]:
-                    return span["attributes"].get("llm.output_messages.0.message.content")
-
-                elif span["name"] == "LLMChain":
-                    return json.loads(span["attributes"].get("output.value", ""))
-
-                elif span["name"] == "RetrievalQA":
-                    return span["attributes"].get("output.value")
-
-        return None
+        try:
+            if tracer_type == "langchain":
+                for span in input_trace:
+                    try:
+                        attributes = span.get("attributes", {})
+                        if attributes:
+                            for key, value in attributes.items():
+                                try:
+                                    if key.startswith("llm.output_messages.") and key.endswith(".message.content"):
+                                        return value
+                                except Exception as e:
+                                    logger.warning(f"Error processing attribute key-value pair for response: {str(e)}")
+                                    continue
+                            
+                            for key, value in attributes.items():
+                                try:
+                                    if key.startswith("output.value"):
+                                        try:
+                                            output_json = json.loads(value)
+                                            if "generations" in output_json and isinstance(output_json.get("generations"), list) and len(output_json.get("generations")) > 0:
+                                                if isinstance(output_json.get("generations")[0], list) and len(output_json.get("generations")[0]) > 0:
+                                                    first_generation = output_json.get("generations")[0][0]
+                                                    if "text" in first_generation:
+                                                        return first_generation["text"]
+                                        except json.JSONDecodeError:
+                                            logger.warning(f"Invalid JSON in output.value: {value}")
+                                            continue
+                                except Exception as e:
+                                    logger.warning(f"Error processing attribute key-value pair for response: {str(e)}")
+                                    continue
+                    except Exception as e:
+                        logger.warning(f"Error processing span for response extraction: {str(e)}")
+                        continue
+                
+                for span in input_trace:
+                    try:
+                        if span["name"] == "LLMChain":
+                            try:
+                                output_value = span["attributes"].get("output.value", "")
+                                if output_value:
+                                    return json.loads(output_value)
+                                return ""
+                            except json.JSONDecodeError:
+                                logger.warning(f"Invalid JSON in LLMChain output.value: {output_value}")
+                                continue
+                        elif span["name"] == "RetrievalQA":
+                            return span["attributes"].get("output.value", "")
+                        elif span["name"] == "VectorStoreRetriever":
+                            return span["attributes"].get("output.value", "")
+                    except Exception as e:
+                        logger.warning(f"Error processing span for fallback response extraction: {str(e)}")
+                        continue
+                
+                logger.warning("No response found in any span")
+                return ""
+            
+            logger.error("Response not found in the trace")
+            return None
+        except Exception as e:
+            logger.error(f"Error while extracting response from trace: {str(e)}")
+            return None
     
     def get_context(input_trace):
-        if user_context.strip():
-            return user_context
-        elif tracer_type == "langchain":
-            for span in input_trace:
-                if span["name"] == "VectorStoreRetriever":
-                    return span["attributes"].get("retrieval.documents.1.document.content")
-        return None
+        try:
+            if user_context and user_context.strip():
+                return user_context
+            elif tracer_type == "langchain":
+                for span in input_trace:
+                    try:
+                        if span["name"] == "VectorStoreRetriever":
+                            return span["attributes"].get("retrieval.documents.1.document.content", "")
+                    except Exception as e:
+                        logger.warning(f"Error processing span for context extraction: {str(e)}")
+                        continue
+            
+            logger.warning("Context not found in the trace")
+            return ""
+        except Exception as e:
+            logger.error(f"Error while extracting context from trace: {str(e)}")
+            return ""
         
     prompt = get_prompt(input_trace)
     response = get_response(input_trace)
@@ -65,14 +177,8 @@ def rag_trace_json_converter(input_trace, custom_model_cost, trace_id, user_deta
     trace_aggregate['trace_id'] = trace_id
     trace_aggregate['session_id'] = None
     trace_aggregate["metadata"] = user_details.get("trace_user_detail", {}).get("metadata")
+    trace_aggregate["pipeline"] = user_details.get("trace_user_detail", {}).get("pipeline")
 
-    #dummy data need to be fetched
-    trace_aggregate["pipeline"] = {
-        'llm_model': 'gpt-4o-mini', 
-        'vector_store': 'faiss',
-        'embed_model': 'text-embedding-ada-002'
-        }
-    
     trace_aggregate["data"] = {}
     trace_aggregate["data"]["prompt"] = prompt
     trace_aggregate["data"]["response"] = response
@@ -95,7 +201,8 @@ def get_additional_metadata(spans, custom_model_cost, model_cost_dict, prompt=""
     additional_metadata["tokens"] = {}
     try:
         for span in spans:
-            if span["name"] in ["ChatOpenAI", "ChatAnthropic", "ChatGoogleGenerativeAI"]:
+            if span["name"] in ["ChatOpenAI", "ChatAnthropic", "ChatGoogleGenerativeAI", "OpenAI", "ChatOpenAI_LangchainOpenAI", "ChatOpenAI_ChatModels",
+                                "ChatVertexAI", "VertexAI", "ChatLiteLLM", "ChatBedrock", "AzureChatOpenAI", "ChatAnthropicVertex"]:
                 start_time = datetime.fromisoformat(span.get("start_time", "")[:-1])  # Remove 'Z' and parse
                 end_time = datetime.fromisoformat(span.get("end_time", "")[:-1])    # Remove 'Z' and parse
                 additional_metadata["latency"] = (end_time - start_time).total_seconds()
@@ -191,55 +298,97 @@ def get_additional_metadata(spans, custom_model_cost, model_cost_dict, prompt=""
     return additional_metadata
 
 def num_tokens_from_messages(model, message):
-    # GPT models
-    if re.match(r'^gpt-', model):
-        """Check if the model is any GPT model (pattern: ^gpt-)
-        This matches any model name that starts with 'gpt-'
-        """
-        def num_tokens_from_string(string: str, encoding_name: str) -> int:
-            """Returns the number of tokens in a text string."""
-            encoding = tiktoken.get_encoding(encoding_name)
-            num_tokens = len(encoding.encode(string))
-            return num_tokens
-        
-        if re.match(r'^gpt-4o.*', model):
-            """Check for GPT-4 Optimized models (pattern: ^gpt-4o.*)
-            Examples that match:
-            - gpt-4o
-            - gpt-4o-mini
-            - gpt-4o-2024-08-06
-            The .* allows for any characters after 'gpt-4o'
-            """
-            encoding_name = "o200k_base"
-            return num_tokens_from_string(message, encoding_name)
-        
-        elif re.match(r'^gpt-(4|3\.5).*', model):
-            """Check for GPT-4 and GPT-3.5 models (pattern: ^gpt-(4|3\.5).*)
-            Uses cl100k_base encoding for GPT-4 and GPT-3.5 models
-            Examples that match:
-            - gpt-4
-            - gpt-4-turbo
-            - gpt-4-2024-08-06
-            - gpt-3.5-turbo
-            - gpt-3.5-turbo-16k
-            """
-            encoding_name = "cl100k_base"
-            return num_tokens_from_string(message, encoding_name)
-        
-        else:
-            """Default case for any other GPT models
-            Uses o200k_base encoding as the default tokenizer
+    try:
+        # Handle None or empty message
+        if not message:
+            logger.warning("Empty or None message provided to token counter")
+            return 0
+            
+        # GPT models
+        if re.match(r'^gpt-', model):
+            """Check if the model is any GPT model (pattern: ^gpt-)
+            This matches any model name that starts with 'gpt-'
             """
-            return num_tokens_from_string(message, encoding_name="o200k_base")
-        
+            def num_tokens_from_string(string: str, encoding_name: str) -> int:
+                """Returns the number of tokens in a text string."""
+                try:
+                    encoding = tiktoken.get_encoding(encoding_name)
+                    num_tokens = len(encoding.encode(string))
+                    return num_tokens
+                except Exception as e:
+                    logger.warning(f"Error encoding with {encoding_name}: {str(e)}")
+                    # Fallback to a different encoding if the requested one fails
+                    try:
+                        fallback_encoding = tiktoken.get_encoding("cl100k_base")
+                        return len(fallback_encoding.encode(string))
+                    except:
+                        logger.error("Failed to use fallback encoding")
+                        return 0
+            
+            if re.match(r'^gpt-4o.*', model):
+                """Check for GPT-4 Optimized models (pattern: ^gpt-4o.*)
+                Examples that match:
+                - gpt-4o
+                - gpt-4o-mini
+                - gpt-4o-2024-08-06
+                The .* allows for any characters after 'gpt-4o'
+                """
+                encoding_name = "o200k_base"
+                return num_tokens_from_string(message, encoding_name)
+            
+            elif re.match(r'^gpt-(4|3\.5).*', model):
+                """Check for GPT-4 and GPT-3.5 models (pattern: ^gpt-(4|3\.5).*)
+                Uses cl100k_base encoding for GPT-4 and GPT-3.5 models
+                Examples that match:
+                - gpt-4
+                - gpt-4-turbo
+                - gpt-4-2024-08-06
+                - gpt-3.5-turbo
+                - gpt-3.5-turbo-16k
+                """
+                encoding_name = "cl100k_base"
+                return num_tokens_from_string(message, encoding_name)
+            
+            else:
+                """Default case for any other GPT models
+                Uses o200k_base encoding as the default tokenizer
+                """
+                return num_tokens_from_string(message, encoding_name="o200k_base")
+            
 
-    # Gemini models 
-    elif re.match(r'^gemini-', model):
-        GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
-        client = genai.Client(api_key=GOOGLE_API_KEY)
+        # Gemini models 
+        elif re.match(r'^gemini-', model):
+            try:
+                GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+                if not GOOGLE_API_KEY:
+                    logger.warning("GOOGLE_API_KEY not found in environment variables")
+                    return 0
+                    
+                import google.generativeai as genai
+                client = genai.Client(api_key=GOOGLE_API_KEY)
 
-        response = client.models.count_tokens(
-                model=model,
-                contents=message,
-            )
-        return response.total_tokens
+                response = client.models.count_tokens(
+                        model=model,
+                        contents=message,
+                    )
+                return response.total_tokens
+            except ImportError:
+                logger.warning("google.generativeai module not found. Install with pip install google-generativeai")
+                return 0
+            except Exception as e:
+                logger.warning(f"Error counting tokens for Gemini model: {str(e)}")
+                return 0
+        
+        # Default case for unknown models
+        else:
+            logger.warning(f"Unknown model type: {model}. Using default token counter.")
+            try:
+                # Use cl100k_base as a fallback for unknown models
+                encoding = tiktoken.get_encoding("cl100k_base")
+                return len(encoding.encode(message))
+            except:
+                logger.error("Failed to use fallback encoding for unknown model")
+                return 0
+    except Exception as e:
+        logger.error(f"Unexpected error in token counting: {str(e)}")
+        return 0

{ragaai_catalyst-2.1.7.1b0.dist-info → ragaai_catalyst-2.1.7.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ragaai_catalyst
-Version: 2.1.7.1b0
+Version: 2.1.7.2
 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>, Tushar Kumar <tushar.kumar@raga.ai>
 Requires-Python: <=3.13.2,>=3.10
@@ -57,8 +57,6 @@ Dynamic: license-file
 
 RagaAI Catalyst is a comprehensive platform designed to enhance the management and optimization of LLM projects. It offers a wide range of features, including project management, dataset management, evaluation management, trace management, prompt management, synthetic data generation, and guardrail management. These functionalities enable you to efficiently evaluate, and safeguard your LLM applications.
 
-![RagaAI Catalyst](docs/img/main.png)
-
 ## Table of Contents
 
 - [RagaAI Catalyst](#ragaai-catalyst)
@@ -149,20 +147,6 @@ dataset_manager.create_from_csv(
     schema_mapping={'column1': 'schema_element1', 'column2': 'schema_element2'}
 )
 
-# Create a dataset from JSONl
-dataset_manager.create_from_jsonl(
-    jsonl_path='jsonl_path',
-    dataset_name='MyDataset',
-    schema_mapping={'column1': 'schema_element1', 'column2': 'schema_element2'}
-)
-
-# Create a dataset from dataframe
-dataset_manager.create_from_df(
-    df=df,
-    dataset_name='MyDataset',
-    schema_mapping={'column1': 'schema_element1', 'column2': 'schema_element2'}
-)
-
 # Get project schema mapping
 dataset_manager.get_schema_mapping()
 
@@ -189,7 +173,6 @@ evaluation = Evaluation(
 evaluation.list_metrics()
 
 # Add metrics to the experiment
-
 schema_mapping={
     'Query': 'prompt',
     'response': 'response',
@@ -303,159 +286,14 @@ tracer = Tracer(
 ```
 
 ```python
+# Enable auto-instrumentation
 from ragaai_catalyst import init_tracing
 init_tracing(catalyst=catalyst, tracer=tracer)
 ```
 
-#### Agentic Tracing Features
-1- add span level metrics
-
-```python
-current_span().add_metrics(name='Accuracy', score=0.5, reasoning='some reasoning')
-```
-
-2- add trace level metrics
-
-```python
-tracer.add_metrics(name='hallucination_1', score=0.5, reasoning='some reasoning')
-```
-
-3- add gt 
-
-```python
-current_span().add_gt("This is the ground truth")
-```
-
-4- add context
-
-```python
-current_span().add_context("This is the context")
-```
-
-5- add span level metric execution
-
-```python
-current_span().execute_metrics(
-    name="Hallucination",
-    model="gpt-4o",
-    provider="openai"
-)
-```
-
-#### Example
-```python
-from ragaai_catalyst import trace_llm, trace_tool, trace_agent, current_span
-
-from openai import OpenAI
-
-
-@trace_llm(name="llm_call", tags=["default_llm_call"])
-def llm_call(prompt, max_tokens=512, model="gpt-4o-mini"):
-    client = OpenAI(api_key=OPENAI_API_KEY)
-    response = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens,
-        temperature=0.85,
-    )
-    # Span level context
-    current_span().add_context("name = span level in summary_agent, context = some span level context")
-
-    # Span level execute metrics
-    current_span().execute_metrics(
-        name="Hallucination",
-        model="gpt-4o",
-        provider="openai"
-    )
-    response_data = response.choices[0].message.content.strip()
-    print('response_data: ', response_data)
-    return response_data
-
-class SummaryAgent:
-    def __init__(self, persona="Summary Agent"):
-        self.persona = persona
-
-    @trace_agent(name="summary_agent")
-    def summarize(self, text):
-        prompt = f"Please summarize this text concisely: {text}"
-
-        # Span level metric
-        current_span().add_metrics(name='Accuracy', score=0.5, reasoning='some reasoning')
-
-        # Span level context
-        current_span().add_context("name = span level in summary_agent, context = some span level context")
-
-        summary = llm_call(prompt)
-        return summary
-
-
-class AnalysisAgent:
-    def __init__(self, persona="Analysis Agent"):
-        self.persona = persona
-        self.summary_agent = SummaryAgent()
-
-    @trace_agent(name="analysis_agent")
-    def analyze(self, text):
-        summary = self.summary_agent.summarize(text)
-
-        prompt = f"Given this summary: {summary}\nProvide a brief analysis of the main points."
-
-        # Span level metric
-        current_span().add_metrics(name='correctness', score=0.5, reasoning='some reasoning')
-        analysis = llm_call(prompt)
-
-        return {
-            "summary": summary,
-            "analysis": analysis
-        }
-
-class RecommendationAgent:
-    def __init__(self, persona="Recommendation Agent"):
-        self.persona = persona
-        self.analysis_agent = AnalysisAgent()
-
-    @trace_agent(name="recommendation_agent", tags=['coordinator_agent'])
-    def recommend(self, text):
-        analysis_result = self.analysis_agent.analyze(text)
-
-        prompt = f"""Given this summary: {analysis_result['summary']}
-        And this analysis: {analysis_result['analysis']}
-        Provide 2-3 actionable recommendations."""
-
-        recommendations = llm_call(prompt)
-
-        return {
-            "summary": analysis_result["summary"],
-            "analysis": analysis_result["analysis"],
-            "recommendations": recommendations
-        }
-#Defining agent tracer
-@trace_agent(name="get_recommendation", tags=['coordinator_agent'])
-def get_recommendation(agent, text):
-    recommendation = agent.recommend(text)
-    return recommendation
-
-def main():
-    text = """
-    Artificial Intelligence has transformed various industries in recent years.
-    From healthcare to finance, AI applications are becoming increasingly prevalent.
-    Machine learning models are being used to predict market trends, diagnose diseases,
-    and automate routine tasks. The impact of AI on society continues to grow,
-    raising both opportunities and challenges for the future.
-    """
-
-    recommendation_agent = RecommendationAgent()
-    result = get_recommendation(recommendation_agent, text)
-
-
-    # Trace level metric
-    tracer.add_metrics(name='hallucination_1', score=0.5, reasoning='some reasoning')
-
-# Run tracer
-with tracer:
-    main()
-```
 ![Tracing](docs/img/last_main.png)
+For more detailed information on Trace Management, please refer to the [Agentic Tracing Management documentation](docs/agentic_tracing.md).
+
 
 ### Prompt Management
 

{ragaai_catalyst-2.1.7.1b0.dist-info → ragaai_catalyst-2.1.7.2.dist-info}/RECORD

@@ -10,7 +10,7 @@ ragaai_catalyst/prompt_manager.py,sha256=W8ypramzOprrJ7-22d5vkBXIuIQ8v9XAzKDGxKs
 ragaai_catalyst/proxy_call.py,sha256=CHxldeceZUaLU-to_hs_Kf1z_b2vHMssLS_cOBedu78,5499
 ragaai_catalyst/ragaai_catalyst.py,sha256=1FaeK_VZpJLQ1ZqEWpMyI8J8M2MI0abLLLDFWY9W-4A,19580
 ragaai_catalyst/redteaming_old.py,sha256=W2d89Ok8W-C8g7TBM3fDIFLof3q9FuYSr0jcryH2XQo,7097
-ragaai_catalyst/synthetic_data_generation.py,sha256=RsaT2sJ4MxvwYU0t4tOTm9lAcsJJEPR3Z_YhG-Lo39g,37880
+ragaai_catalyst/synthetic_data_generation.py,sha256=7lIWa3nwgW2-FlJrDaGxTN6OE4-dbbhLtKNOBQufhho,37952
 ragaai_catalyst/utils.py,sha256=TlhEFwLyRU690HvANbyoRycR3nQ67lxVUQoUOfTPYQ0,3772
 ragaai_catalyst/redteaming/__init__.py,sha256=TJdvZpaZGFsg9qKONdjTosSVLZGadYFpHG6KE0xapKU,155
 ragaai_catalyst/redteaming/evaluator.py,sha256=C50SAc3RsR7PZnz-VQ7wQfDpiVEb7T3W3KV4Lj0tWYE,4599
@@ -85,11 +85,11 @@ ragaai_catalyst/tracers/utils/convert_llama_instru_callback.py,sha256=8qLo7x4Zsn
 ragaai_catalyst/tracers/utils/extraction_logic_llama_index.py,sha256=ZhPs0YhVtB82-Pq9o1BvCinKE_WPvVxPTEcZjlJbFYM,2371
 ragaai_catalyst/tracers/utils/langchain_tracer_extraction_logic.py,sha256=XS2_x2qneqEx9oAighLg-LRiueWcESLwIC2r7eJT-Ww,3117
 ragaai_catalyst/tracers/utils/model_prices_and_context_window_backup.json,sha256=C3uwkibJ08C9sOX-54kulZYmJlIpZ-SQpfE6HNGrjbM,343502
-ragaai_catalyst/tracers/utils/rag_trace_json_converter.py,sha256=sIUWwzXlEGU8wkVVL0w944tXxsOVdUHHV9UCImvBVOU,11406
+ragaai_catalyst/tracers/utils/rag_trace_json_converter.py,sha256=yq1vp1O94xXIX9IUsns5VqsfIDU83Eqn5XzJEJGh-Bs,20637
 ragaai_catalyst/tracers/utils/trace_json_converter.py,sha256=E0_QfciQMMpCtQYrNB4l8HJhlaFalr5bkMqkVRgQahY,14073
 ragaai_catalyst/tracers/utils/utils.py,sha256=ViygfJ7vZ7U0CTSA1lbxVloHp4NSlmfDzBRNCJuMhis,2374
-ragaai_catalyst-2.1.7.1b0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-ragaai_catalyst-2.1.7.1b0.dist-info/METADATA,sha256=XmXgArVT9fOkKtws19dhu-OsyD4wAyinuEGl5z1VnoQ,22151
-ragaai_catalyst-2.1.7.1b0.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
-ragaai_catalyst-2.1.7.1b0.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
-ragaai_catalyst-2.1.7.1b0.dist-info/RECORD,,
+ragaai_catalyst-2.1.7.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+ragaai_catalyst-2.1.7.2.dist-info/METADATA,sha256=4idPE4h-NhbrCeTAjM4Ud00KQeI7mCjRCIwwsjdE-2M,17605
+ragaai_catalyst-2.1.7.2.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+ragaai_catalyst-2.1.7.2.dist-info/top_level.txt,sha256=HpgsdRgEJMk8nqrU6qdCYk3di7MJkDL0B19lkc7dLfM,16
+ragaai_catalyst-2.1.7.2.dist-info/RECORD,,

{ragaai_catalyst-2.1.7.1b0.dist-info → ragaai_catalyst-2.1.7.2.dist-info}/WHEEL

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