pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/snippets/chat/chat_completion_with_reasoning_effort.py

@@ -0,0 +1,18 @@
+from pygeai.chat.clients import ChatClient
+
+client = ChatClient()
+
+messages = [
+    {
+        "role": "user",
+        "content": "Explain quantum computing in simple terms"
+    }
+]
+
+response = client.chat_completion(
+    model="openai/gpt-4o",
+    messages=messages,
+    reasoning_effort="high"
+)
+
+print(response)

pygeai/tests/snippets/chat/get_response.py

@@ -0,0 +1,15 @@
+from pygeai.chat.clients import ChatClient
+
+client = ChatClient()
+
+model = "openai/o1-pro"
+input_text = "What is the weather like in Paris today?"
+
+response = client.get_response(
+    model=model,
+    input=input_text,
+    temperature=0.7,
+    max_output_tokens=1000
+)
+
+print(response)

pygeai/tests/snippets/chat/get_response_complete_example.py

@@ -0,0 +1,67 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Comprehensive usage of get_response with all major parameters
+client = ChatClient()
+
+model = "openai/gpt-4-turbo-preview"
+input_text = "Analyze the benefits of renewable energy and suggest implementation strategies"
+
+# Define a tool for additional data retrieval
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_energy_stats",
+            "description": "Get statistics about renewable energy adoption",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "country": {
+                        "type": "string",
+                        "description": "Country name"
+                    },
+                    "year": {
+                        "type": "integer",
+                        "description": "Year for statistics"
+                    }
+                },
+                "required": ["country"]
+            }
+        }
+    }
+]
+
+# Comprehensive configuration
+response = client.get_response(
+    model=model,
+    input=input_text,
+    instructions="You are an energy policy expert. Provide detailed, data-driven analysis with actionable recommendations.",
+    tools=tools,
+    tool_choice="auto",  # Let the model decide when to use tools
+    parallel_tool_calls=True,
+    temperature=0.7,
+    max_output_tokens=2000,
+    top_p=0.9,
+    metadata={
+        "request_id": "energy_analysis_001",
+        "department": "sustainability",
+        "priority": "high"
+    },
+    user="analyst_john_doe",
+    reasoning={
+        "effort": "high"  # Request thorough reasoning
+    },
+    truncation="auto",
+    store=True  # Store for future reference
+)
+
+print("=== Comprehensive Response ===")
+print(response)
+
+# Extract key information if response is a dict
+if isinstance(response, dict):
+    print("\n=== Response Metadata ===")
+    if "usage" in response:
+        print(f"Tokens used: {response['usage']}")
+    if "model" in response:
+        print(f"Model used: {response['model']}")

pygeai/tests/snippets/chat/get_response_streaming.py

@@ -0,0 +1,20 @@
+from pygeai.chat.clients import ChatClient
+
+client = ChatClient()
+
+model = "openai/o1-pro"
+input_text = "Tell me a short story about a robot"
+
+response = client.get_response(
+    model=model,
+    input=input_text,
+    stream=True,
+    temperature=0.7,
+    max_output_tokens=500
+)
+
+print("Streaming response:")
+for chunk in response:
+    print(chunk, end='', flush=True)
+
+print("\n\nStreaming complete!")

pygeai/tests/snippets/chat/get_response_with_files.py

@@ -0,0 +1,16 @@
+from pygeai.chat.clients import ChatClient
+
+client = ChatClient()
+
+model = "openai/o1-pro"
+input_text = "Please analyze this image and describe what you see"
+files = ["files/image.svg", "files/document.pdf"]
+
+response = client.get_response(
+    model=model,
+    input=input_text,
+    files=files,
+    temperature=0.7
+)
+
+print(response)

pygeai/tests/snippets/chat/get_response_with_instructions.py

@@ -0,0 +1,19 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Using get_response with custom instructions
+client = ChatClient()
+
+model = "openai/gpt-4-turbo-preview"
+input_text = "Tell me about machine learning"
+
+# Using instructions to customize the model's behavior
+response = client.get_response(
+    model=model,
+    input=input_text,
+    instructions="You are an expert educator who explains complex topics in simple terms suitable for beginners. Always use analogies and examples.",
+    temperature=0.8,
+    max_output_tokens=1500
+)
+
+print("Response with custom instructions:")
+print(response)

pygeai/tests/snippets/chat/get_response_with_metadata.py

@@ -0,0 +1,24 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Using get_response with metadata and user identification
+client = ChatClient()
+
+model = "openai/gpt-4-turbo-preview"
+input_text = "What are the benefits of using AI in healthcare?"
+
+# Using metadata to pass additional context
+response = client.get_response(
+    model=model,
+    input=input_text,
+    metadata={
+        "request_id": "req_12345",
+        "department": "healthcare",
+        "priority": "high"
+    },
+    user="user_jane_doe",  # User identifier for tracking
+    temperature=0.7,
+    max_output_tokens=1500
+)
+
+print("Response with metadata:")
+print(response)

pygeai/tests/snippets/chat/get_response_with_parallel_tools.py

@@ -0,0 +1,58 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Using get_response with parallel tool calls
+client = ChatClient()
+
+model = "openai/gpt-4-turbo-preview"
+input_text = "What's the weather in New York and what time is it in Tokyo?"
+
+# Define tools
+tools = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather",
+            "description": "Get current weather for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "City name"
+                    }
+                },
+                "required": ["location"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_time",
+            "description": "Get current time for a location",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "location": {
+                        "type": "string",
+                        "description": "City name"
+                    }
+                },
+                "required": ["location"]
+            }
+        }
+    }
+]
+
+# Enable parallel tool calls to execute both tools simultaneously
+response = client.get_response(
+    model=model,
+    input=input_text,
+    tools=tools,
+    parallel_tool_calls=True,  # Allow multiple tools to be called in parallel
+    temperature=0.7,
+    max_output_tokens=1000
+)
+
+print("Response with parallel tool calls:")
+print(response)

pygeai/tests/snippets/chat/get_response_with_reasoning.py

@@ -0,0 +1,21 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Using get_response with reasoning parameter
+client = ChatClient()
+
+model = "openai/o1-preview"
+input_text = "Explain the concept of quantum entanglement in simple terms"
+
+# Using reasoning parameter to control reasoning effort
+response = client.get_response(
+    model=model,
+    input=input_text,
+    reasoning={
+        "type": "default",  # Can be "default", "high", "medium", "low"
+        "effort": "medium"
+    },
+    max_output_tokens=2000
+)
+
+print("Response with reasoning:")
+print(response)

pygeai/tests/snippets/chat/get_response_with_store.py

@@ -0,0 +1,38 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Using get_response with store parameter to persist conversation
+client = ChatClient()
+
+model = "openai/gpt-4-turbo-preview"
+input_text = "Remember that my favorite color is blue. What did I just tell you?"
+
+# Use store parameter to enable conversation storage
+response = client.get_response(
+    model=model,
+    input=input_text,
+    store=True,  # Store this conversation for future reference
+    user="user_123",  # Associate with specific user
+    metadata={
+        "session_id": "session_abc",
+        "conversation_type": "preference_learning"
+    },
+    temperature=0.7,
+    max_output_tokens=500
+)
+
+print("Response with conversation storage:")
+print(response)
+
+# Follow-up request can reference stored context
+follow_up = client.get_response(
+    model=model,
+    input="What's my favorite color?",
+    store=True,
+    user="user_123",
+    metadata={
+        "session_id": "session_abc"
+    }
+)
+
+print("\nFollow-up response:")
+print(follow_up)

pygeai/tests/snippets/chat/get_response_with_tools.py

@@ -0,0 +1,36 @@
+from pygeai.chat.clients import ChatClient
+
+client = ChatClient()
+
+model = "openai/o1-pro"
+input_text = "What is the weather like in Paris today?"
+
+tools = [
+    {
+        "type": "function",
+        "name": "get_weather",
+        "description": "Get current temperature for a given location.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "location": {
+                    "type": "string",
+                    "description": "City and country e.g. Paris, France"
+                }
+            },
+            "required": ["location"],
+            "additionalProperties": False
+        }
+    }
+]
+
+response = client.get_response(
+    model=model,
+    input=input_text,
+    tools=tools,
+    tool_choice="auto",
+    temperature=1.0,
+    reasoning={"effort": "medium"}
+)
+
+print(response)

pygeai/tests/snippets/chat/get_response_with_truncation.py

@@ -0,0 +1,24 @@
+from pygeai.chat.clients import ChatClient
+
+# Example: Using get_response with truncation strategy
+client = ChatClient()
+
+model = "openai/gpt-4-turbo-preview"
+input_text = """
+This is a very long input text that might exceed the context window.
+Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed do eiusmod 
+tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam,
+quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat.
+""" * 100  # Simulate long input
+
+# Using truncation to handle long inputs
+response = client.get_response(
+    model=model,
+    input=input_text,
+    truncation="auto",  # Options: "auto", "disabled"
+    max_output_tokens=1000,
+    temperature=0.7
+)
+
+print("Response with truncation handling:")
+print(response)

pygeai/tests/snippets/dbg/basic_debugging.py

@@ -0,0 +1,32 @@
+"""
+Basic debugging example with geai-dbg.
+
+This demonstrates setting breakpoints and inspecting variables.
+"""
+from pygeai.dbg.debugger import Debugger
+
+
+def example_function(x, y):
+    """A simple function to debug."""
+    result = x + y
+    print(f"Result: {result}")
+    return result
+
+
+def main():
+    """Main entry point."""
+    a = 10
+    b = 20
+    c = example_function(a, b)
+    print(f"Final value: {c}")
+
+
+if __name__ == "__main__":
+    dbg = Debugger(target=main, module_filter="__main__")
+    dbg.add_breakpoint(module="__main__", function_name="example_function")
+    
+    print("Starting debugger...")
+    print("Type 'h' for help")
+    print("Try commands like: 'p x', 'p y', 'locals', 's', 'n', 'c'")
+    
+    dbg.run()

pygeai/tests/snippets/dbg/breakpoint_management.py

@@ -0,0 +1,48 @@
+"""
+Demonstrates breakpoint management (add, list, remove, enable/disable).
+"""
+from pygeai.dbg.debugger import Debugger
+
+
+def func_a():
+    """Function A."""
+    print("In function A")
+    return "A"
+
+
+def func_b():
+    """Function B."""
+    print("In function B")
+    return "B"
+
+
+def func_c():
+    """Function C."""
+    print("In function C")
+    return "C"
+
+
+def main():
+    """Main entry point."""
+    results = []
+    results.append(func_a())
+    results.append(func_b())
+    results.append(func_c())
+    print(f"Results: {results}")
+
+
+if __name__ == "__main__":
+    dbg = Debugger(target=main, module_filter="__main__")
+    
+    print("Starting debugger...")
+    print("No breakpoints set initially. At first function, try:")
+    print("  'b func_b' - add breakpoint on func_b")
+    print("  'b __main__:func_c' - add breakpoint on specific module:function")
+    print("  'b' - list all breakpoints")
+    print("  'dis func_b' - disable breakpoint on func_b")
+    print("  'en func_b' - enable breakpoint on func_b")
+    print("  'cl func_b' - remove breakpoint on func_b")
+    print("  'c' - continue to next breakpoint")
+    
+    dbg.add_breakpoint(module="__main__", function_name="func_a")
+    dbg.run()

pygeai/tests/snippets/dbg/file_debugging.py

@@ -0,0 +1,72 @@
+"""
+Example of debugging a standalone Python file using geai-dbg.
+
+This demonstrates how to use debug_file() to debug any Python script.
+"""
+from pygeai.dbg import debug_file
+import tempfile
+import os
+
+
+def create_sample_script():
+    """Create a sample script to debug."""
+    code = '''
+def process_data(items):
+    """Process a list of items."""
+    result = []
+    for item in items:
+        result.append(item * 2)
+    return result
+
+
+def main():
+    """Main entry point."""
+    data = [1, 2, 3, 4, 5]
+    processed = process_data(data)
+    print(f"Processed: {processed}")
+    return processed
+
+
+if __name__ == "__main__":
+    main()
+'''
+    
+    fd, filepath = tempfile.mkstemp(suffix='.py', text=True)
+    try:
+        os.write(fd, code.encode())
+    finally:
+        os.close(fd)
+    
+    return filepath
+
+
+def main():
+    """Demonstrate file debugging."""
+    print("Creating sample script...")
+    script_path = create_sample_script()
+    
+    try:
+        print(f"Script created at: {script_path}")
+        print("\nSetting up debugger...")
+        
+        dbg = debug_file(script_path)
+        dbg.add_breakpoint(function_name='process_data')
+        
+        print("Debugger configured with breakpoint on 'process_data'")
+        print("\nTo run interactively, uncomment the line below:")
+        print("# dbg.run()")
+        print("\nCommands you can use:")
+        print("  c     - continue")
+        print("  s     - step into")
+        print("  n     - next line")
+        print("  p     - print variable (e.g., 'p items')")
+        print("  l     - list source")
+        print("  h     - help")
+        
+    finally:
+        os.unlink(script_path)
+        print(f"\nCleaned up {script_path}")
+
+
+if __name__ == "__main__":
+    main()

pygeai/tests/snippets/dbg/module_debugging.py

@@ -0,0 +1,61 @@
+"""
+Example of debugging a specific module and function using geai-dbg.
+
+This demonstrates how to use debug_module() to debug imported modules.
+"""
+from pygeai.dbg import debug_module
+
+
+def example_simple_module():
+    """Debug a simple built-in module."""
+    print("Example: Debugging os.path.exists function")
+    print("\nThis would set up a debugger for the os.path.exists function:")
+    print("  dbg = debug_module('os.path', 'exists')")
+    print("  dbg.run()")
+    print("\nNote: This is for demonstration. Built-in functions may not be traceable.")
+
+
+def example_pygeai_module():
+    """Debug a PyGEAI module."""
+    print("\nExample: Debugging PyGEAI modules")
+    print("\nYou can debug any PyGEAI module function:")
+    print("  from pygeai.dbg import debug_module")
+    print("  ")
+    print("  # Debug the chat module")
+    print("  dbg = debug_module('pygeai.chat', 'send_message')")
+    print("  dbg.add_breakpoint(module='pygeai.core.llm', function_name='get_completion')")
+    print("  dbg.run()")
+
+
+def example_cli_debugging():
+    """Debug the geai CLI programmatically."""
+    print("\nExample: Debugging geai CLI programmatically")
+    print("\nInstead of using 'geai-dbg', you can set it up in code:")
+    print("  from pygeai.dbg import debug_module")
+    print("  ")
+    print("  # Set up debugging with custom breakpoints")
+    print("  dbg = debug_module('pygeai.cli.geai', 'main')")
+    print("  dbg.add_breakpoint(module='pygeai.cli.commands', function_name='execute')")
+    print("  dbg.run()")
+
+
+def main():
+    """Run all examples."""
+    print("=" * 70)
+    print("Module Debugging Examples")
+    print("=" * 70)
+    
+    example_simple_module()
+    example_pygeai_module()
+    example_cli_debugging()
+    
+    print("\n" + "=" * 70)
+    print("To use module debugging from the command line:")
+    print("=" * 70)
+    print("  geai-dbg -m pygeai.cli.geai:main")
+    print("  geai-dbg -m pygeai.chat:send_message -b process_response")
+    print("=" * 70)
+
+
+if __name__ == "__main__":
+    main()

pygeai/tests/snippets/dbg/stack_navigation.py

@@ -0,0 +1,45 @@
+"""
+Demonstrates stack navigation (up, down, where).
+"""
+from pygeai.dbg.debugger import Debugger
+
+
+def level_3():
+    """Deepest level of call stack."""
+    value = "level 3"
+    print(f"At {value}")
+    return value
+
+
+def level_2():
+    """Middle level of call stack."""
+    value = "level 2"
+    result = level_3()
+    return f"{value} -> {result}"
+
+
+def level_1():
+    """Top level of call stack."""
+    value = "level 1"
+    result = level_2()
+    return f"{value} -> {result}"
+
+
+def main():
+    """Main entry point."""
+    result = level_1()
+    print(f"Final: {result}")
+
+
+if __name__ == "__main__":
+    dbg = Debugger(target=main, module_filter="__main__")
+    dbg.add_breakpoint(module="__main__", function_name="level_3")
+    
+    print("Starting debugger...")
+    print("At breakpoint in level_3, try:")
+    print("  'where' or 'bt' - show call stack")
+    print("  'up' - move to level_2 frame")
+    print("  'down' - move back to level_3 frame")
+    print("  'locals' - show local variables in current frame")
+    
+    dbg.run()

pygeai/tests/snippets/dbg/stepping_example.py

@@ -0,0 +1,40 @@
+"""
+Demonstrates stepping functionality (step, next, return).
+"""
+from pygeai.dbg.debugger import Debugger
+
+
+def helper_function(n):
+    """Helper function to demonstrate step-into."""
+    doubled = n * 2
+    return doubled
+
+
+def process_data(data):
+    """Process some data."""
+    result = []
+    for item in data:
+        processed = helper_function(item)
+        result.append(processed)
+    return result
+
+
+def main():
+    """Main entry point."""
+    numbers = [1, 2, 3, 4, 5]
+    processed = process_data(numbers)
+    print(f"Processed: {processed}")
+
+
+if __name__ == "__main__":
+    dbg = Debugger(target=main, module_filter="__main__")
+    dbg.add_breakpoint(module="__main__", function_name="process_data")
+    
+    print("Starting debugger...")
+    print("At breakpoint, try:")
+    print("  's' - step into helper_function")
+    print("  'n' - step over helper_function call")
+    print("  'ret' - return from current function")
+    print("  'l' - list source code")
+    
+    dbg.run()