ragaai-catalyst 2.2.4b5__py3-none-any.whl → 2.2.5b2__py3-none-any.whl

ragaai_catalyst/tracers/agentic_tracing/tests/ai_travel_agent.py

@@ -1,197 +0,0 @@
-import os
-import json
-from openai import OpenAI
-import requests
-from datetime import datetime
-from dotenv import load_dotenv
-import sys
-
-# Load environment variables
-load_dotenv()
-
-# Initialize OpenAI client
-client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
-
-# Initialize tracer
-from tracer import Tracer
-tracer = Tracer(
-    project_name="travel_agent_demo",
-    output_dir="./traces"
-)
-
-# Start tracing
-tracer.start()
-
-@tracer.trace_tool(
-    name="llm_call",
-    tool_type="llm",
-    version="1.0.0"
-)
-def llm_call(prompt, max_tokens=512, model="gpt-3.5-turbo"):
-    response = client.chat.completions.create(
-        model=model,
-        messages=[{"role": "user", "content": prompt}],
-        max_tokens=max_tokens,
-        temperature=0.7,
-    )
-    return response.choices[0].message.content.strip()
-
-@tracer.trace_tool(
-    name="weather_tool",
-    tool_type="api",
-    version="1.0.0"
-)
-def weather_tool(destination):
-    api_key = os.environ.get("OPENWEATHERMAP_API_KEY")
-    base_url = "http://api.openweathermap.org/data/2.5/weather"
-    params = {"q": destination, "appid": api_key, "units": "metric"}
-
-    try:
-        response = requests.get(base_url, params=params)
-        response.raise_for_status()
-        data = response.json()
-        weather_description = data["weather"][0]["description"]
-        temperature = data["main"]["temp"]
-        return f"{weather_description.capitalize()}, {temperature:.1f}°C"
-    except requests.RequestException:
-        return "Weather data not available."
-
-@tracer.trace_tool(
-    name="currency_converter_tool",
-    tool_type="api",
-    version="1.0.0"
-)
-def currency_converter_tool(amount, from_currency, to_currency):
-    api_key = os.environ.get("EXCHANGERATE_API_KEY")
-    base_url = f"https://v6.exchangerate-api.com/v6/{api_key}/pair/{from_currency}/{to_currency}"
-
-    try:
-        response = requests.get(base_url)
-        response.raise_for_status()
-        data = response.json()
-        if data["result"] == "success":
-            rate = data["conversion_rate"]
-            return amount * rate
-        return None
-    except requests.RequestException:
-        return None
-
-@tracer.trace_tool(
-    name="flight_price_estimator_tool",
-    tool_type="mock",
-    version="1.0.0"
-)
-def flight_price_estimator_tool(origin, destination):
-    return f"Estimated price from {origin} to {destination}: $500-$1000"
-
-@tracer.trace_agent(
-    name="itinerary_agent",
-    agent_type="planner",
-    capabilities=["itinerary_planning", "llm_interaction"]
-)
-class ItineraryAgent:
-    def __init__(self, persona="Itinerary Agent"):
-        self.persona = persona
-
-    def plan_itinerary(self, user_preferences, duration=3):
-            itinerary_prompt = f"""
-You are a travel expert named {self.persona}.
-Based on the following user preferences, create a {duration}-day travel itinerary.
-
-User Preferences:
-{user_preferences}
-
-Itinerary:
-"""
-            return llm_call(itinerary_prompt, max_tokens=512)
-
-@tracer.trace_agent(
-    name="travel_agent",
-    agent_type="orchestrator",
-    capabilities=["preference_extraction", "travel_planning", "information_gathering"]
-)
-def travel_agent():
-    print("Welcome to the Personalized Travel Planner!\n")
-
-    # Get user input
-    user_input = "karela, 10 days, $100, nature"
-
-    # Extract preferences
-    preferences_prompt = f"""
-Extract key travel preferences from the following user input:
-"{user_input}"
-
-Please provide the extracted information in this format:
-Destination:
-Activities:
-Budget:
-Duration (in days):
-"""
-    extracted_preferences = llm_call(preferences_prompt)
-    print("\nExtracted Preferences:")
-    print(extracted_preferences)
-
-    # Parse extracted preferences
-    preferences = {}
-    for line in extracted_preferences.split("\n"):
-        if ":" in line:
-            key, value = line.split(":", 1)
-            preferences[key.strip()] = value.strip()
-
-    # Validate extracted preferences
-    required_keys = ["Destination", "Activities", "Budget", "Duration (in days)"]
-    if not all(key in preferences for key in required_keys):
-        print("\nCould not extract all required preferences. Please try again.")
-        return
-
-    # Fetch additional information
-    weather = weather_tool(preferences["Destination"])
-    print(f"\nWeather in {preferences['Destination']}: {weather}")
-
-    origin = "delhi"
-    flight_price = flight_price_estimator_tool(origin, preferences["Destination"])
-    print(flight_price)
-
-    # Plan itinerary
-    itinerary_agent = ItineraryAgent()
-    itinerary = itinerary_agent.plan_itinerary(
-        extracted_preferences, int(preferences["Duration (in days)"])
-    )
-    print("\nPlanned Itinerary:")
-    print(itinerary)
-
-    # Currency conversion
-    budget_amount = float(preferences["Budget"].replace("$", "").replace(",", ""))
-    converted_budget = currency_converter_tool(budget_amount, "USD", "INR")
-    if converted_budget:
-        print(f"\nBudget in INR: {converted_budget:.2f} INR")
-    else:
-        print("\nCurrency conversion not available.")
-
-    # Generate travel summary
-    summary_prompt = f"""
-Summarize the following travel plan:
-
-Destination: {preferences['Destination']}
-Activities: {preferences['Activities']}
-Budget: {preferences['Budget']}
-Duration: {preferences['Duration (in days)']} days
-Itinerary: {itinerary}
-Weather: {weather}
-Flight Price: {flight_price}
-
-Travel Summary:
-"""
-    travel_summary = llm_call(summary_prompt, max_tokens=2048)
-    print("\nTravel Summary:")
-    print(travel_summary)
-
-def main():
-    try:
-        travel_agent()
-    finally:
-        # Stop tracing and save results
-        tracer.stop()
-
-if __name__ == "__main__":
-    main()

ragaai_catalyst/tracers/agentic_tracing/tests/unique_decorator_test.py

@@ -1,172 +0,0 @@
-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)