pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/snippets/chat/send_chat_request.py

@@ -0,0 +1,33 @@
+from pygeai.assistant.managers import AssistantManager
+from pygeai.core.models import Assistant, ChatMessageList, ChatMessage, AssistantRevision, \
+    ChatVariableList, ChatVariable
+
+assistant = Assistant(
+    id="3372b866-36b3-4541-8897-d371dab99f10",
+    name='Welcome data Assistant 4',
+)
+
+messages = ChatMessageList(
+    messages=[
+        ChatMessage(role="user", content="Hello!"),
+        ChatMessage(role="assistant", content="Hi there! How can I help?")
+    ]
+)
+
+revision = AssistantRevision(
+    revision_id=1.0,
+    revision_name="Default"
+)
+
+variables = ChatVariableList(
+    variables=[
+        ChatVariable(key="user_name", value="John Doe")
+    ]
+)
+
+
+manager = AssistantManager()
+#response = client.send_chat_request(assistant, messages, revision, variables)
+response = manager.send_chat_request(assistant, messages)
+
+print("Response:", 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()

pygeai/tests/snippets/embeddings/cache_example.py

@@ -0,0 +1,31 @@
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.services.llm.model import Model
+from pygeai.core.services.llm.providers import Provider
+import time
+
+manager = EmbeddingsManager()
+
+inputs = ["This text will be cached for faster repeated access"]
+
+configuration = EmbeddingConfiguration(
+    inputs=inputs,
+    model=f"{Provider.OPENAI}/{Model.OpenAI.TEXT_EMBEDDING_3_SMALL}",
+    cache=True
+)
+
+print("First request (not cached)...")
+start = time.time()
+embeddings1 = manager.generate_embeddings(configuration)
+elapsed1 = time.time() - start
+print(f"Time: {elapsed1:.3f}s")
+print(f"Cost: ${embeddings1.usage.total_cost} {embeddings1.usage.currency}")
+
+print("\nSecond request (should be cached)...")
+start = time.time()
+embeddings2 = manager.generate_embeddings(configuration)
+elapsed2 = time.time() - start
+print(f"Time: {elapsed2:.3f}s")
+print(f"Cost: ${embeddings2.usage.total_cost} {embeddings2.usage.currency}")
+
+print(f"\nCache speedup: {elapsed1/elapsed2:.2f}x faster")

pygeai/tests/snippets/embeddings/cohere_example.py

@@ -0,0 +1,41 @@
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.services.llm.model import Model
+from pygeai.core.services.llm.providers import Provider
+
+manager = EmbeddingsManager()
+
+document_inputs = [
+    "Machine learning is a subset of artificial intelligence",
+    "Neural networks are inspired by the human brain"
+]
+
+configuration = EmbeddingConfiguration(
+    inputs=document_inputs,
+    model=f"{Provider.COHERE}/{Model.Cohere.EMBED_ENGLISH_V3_0}",
+    input_type="search_document",
+    timeout=600,
+    cache=False
+)
+
+embeddings = manager.generate_embeddings(configuration)
+
+print(f"Model: {embeddings.model}")
+print(f"Input type: search_document")
+print(f"Documents embedded: {len(embeddings.data)}")
+print(f"Usage - Prompt tokens: {embeddings.usage.prompt_tokens}")
+print(f"Usage - Total cost: ${embeddings.usage.total_cost} {embeddings.usage.currency}")
+
+query_input = ["What is neural network?"]
+
+query_configuration = EmbeddingConfiguration(
+    inputs=query_input,
+    model=f"{Provider.COHERE}/{Model.Cohere.EMBED_ENGLISH_V3_0}",
+    input_type="search_query",
+    timeout=600,
+    cache=False
+)
+
+query_embeddings = manager.generate_embeddings(query_configuration)
+print(f"\nQuery embedded with input_type: search_query")
+print(f"Usage - Total cost: ${query_embeddings.usage.total_cost} {query_embeddings.usage.currency}")

pygeai/tests/snippets/embeddings/generate_embeddings.py

@@ -0,0 +1,26 @@
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.services.llm.model import Model
+from pygeai.core.services.llm.providers import Provider
+
+manager = EmbeddingsManager()
+
+inputs = [
+    "Help me with Globant Enterprise AI",
+    "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAIAAACQd1PeAAAAEElEQVR4nGK6HcwNCAAA//8DTgE8HuxwEQAAAABJRU5ErkJggg=="
+]
+
+
+configuration = EmbeddingConfiguration(
+    inputs=inputs,
+    model=f"{Provider.AWS_BEDROCK}/{Model.AWSBedrock.AMAZON_TITAN_EMBED_IMAGE_V1}",
+    encoding_format=None,
+    dimensions=None,
+    user=None,
+    input_type=None,
+    timeout=600,
+    cache=False
+)
+
+embeddings = manager.generate_embeddings(configuration)
+print(embeddings)

pygeai/tests/snippets/embeddings/openai_base64_example.py

@@ -0,0 +1,27 @@
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.services.llm.model import Model
+from pygeai.core.services.llm.providers import Provider
+
+manager = EmbeddingsManager()
+
+inputs = ["Text to embed with base64 encoding"]
+
+configuration = EmbeddingConfiguration(
+    inputs=inputs,
+    model=f"{Provider.OPENAI}/{Model.OpenAI.TEXT_EMBEDDING_3_SMALL}",
+    encoding_format="base64",
+    dimensions=512,
+    user=None,
+    input_type=None,
+    timeout=600,
+    cache=False
+)
+
+embeddings = manager.generate_embeddings(configuration)
+
+print(f"Model: {embeddings.model}")
+print(f"Encoding format: base64")
+print(f"Embedding (base64 encoded, first 100 chars): {embeddings.data[0].embedding[:100]}")
+print(f"Type of embedding: {type(embeddings.data[0].embedding)}")
+print(f"Usage - Total cost: ${embeddings.usage.total_cost} {embeddings.usage.currency}")

pygeai/tests/snippets/embeddings/openai_example.py

@@ -0,0 +1,30 @@
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.services.llm.model import Model
+from pygeai.core.services.llm.providers import Provider
+
+manager = EmbeddingsManager()
+
+inputs = [
+    "The quick brown fox jumps over the lazy dog",
+    "Python is a high-level programming language"
+]
+
+configuration = EmbeddingConfiguration(
+    inputs=inputs,
+    model=f"{Provider.OPENAI}/{Model.OpenAI.TEXT_EMBEDDING_3_SMALL}",
+    encoding_format="float",
+    dimensions=1536,
+    user=None,
+    input_type=None,
+    timeout=600,
+    cache=False
+)
+
+embeddings = manager.generate_embeddings(configuration)
+
+print(f"Model: {embeddings.model}")
+print(f"Total embeddings generated: {len(embeddings.data)}")
+print(f"Embedding dimensions: {len(embeddings.data[0].embedding)}")
+print(f"Usage - Prompt tokens: {embeddings.usage.prompt_tokens}")
+print(f"Usage - Total cost: ${embeddings.usage.total_cost} {embeddings.usage.currency}")

pygeai/tests/snippets/embeddings/similarity_example.py

@@ -0,0 +1,42 @@
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.services.llm.model import Model
+from pygeai.core.services.llm.providers import Provider
+import numpy as np
+
+def cosine_similarity(vec1, vec2):
+    """Calculate cosine similarity between two vectors."""
+    vec1 = np.array(vec1)
+    vec2 = np.array(vec2)
+    return np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+
+manager = EmbeddingsManager()
+
+texts = [
+    "The cat sits on the mat",
+    "A feline rests on a rug",
+    "Python is a programming language"
+]
+
+configuration = EmbeddingConfiguration(
+    inputs=texts,
+    model=f"{Provider.OPENAI}/{Model.OpenAI.TEXT_EMBEDDING_3_SMALL}",
+)
+
+embeddings = manager.generate_embeddings(configuration)
+
+embedding_vectors = [emb.embedding for emb in embeddings.data]
+
+print("Cosine Similarity Matrix:")
+print("=" * 60)
+for i, text1 in enumerate(texts):
+    for j, text2 in enumerate(texts):
+        if i <= j:
+            similarity = cosine_similarity(embedding_vectors[i], embedding_vectors[j])
+            print(f"\nText {i+1} vs Text {j+1}: {similarity:.4f}")
+            if i != j:
+                print(f"  '{text1[:40]}...'")
+                print(f"  '{text2[:40]}...'")
+
+print(f"\n{'='*60}")
+print(f"Total cost: ${embeddings.usage.total_cost} {embeddings.usage.currency}")