pygeai 0.6.0b6__py3-none-any.whl → 0.6.0b10__py3-none-any.whl

pygeai/tests/organization/test_managers.py

@@ -9,7 +9,8 @@ from pygeai.core.base.responses import EmptyResponse
 from pygeai.organization.managers import OrganizationManager
 from pygeai.organization.mappers import OrganizationResponseMapper
 from pygeai.organization.responses import AssistantListResponse, ProjectListResponse, ProjectDataResponse, \
-    ProjectTokensResponse, ProjectItemListResponse
+    ProjectTokensResponse, ProjectItemListResponse, MembershipsResponse, ProjectMembershipsResponse, \
+    ProjectRolesResponse, ProjectMembersResponse, OrganizationMembersResponse
 
 
 class TestOrganizationManager(unittest.TestCase):
@@ -261,3 +262,123 @@ class TestOrganizationManager(unittest.TestCase):
             skip=0,
             count=0
         )
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_memberships")
+    def test_get_memberships(self, mock_get_memberships):
+        mock_response = MembershipsResponse(count=0, pages=0, organizations=[])
+        mock_get_memberships.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_memberships_response', return_value=mock_response):
+            response = self.manager.get_memberships()
+
+        self.assertIsInstance(response, MembershipsResponse)
+        self.assertEqual(response.count, 0)
+        mock_get_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_memberships")
+    def test_get_memberships_error(self, mock_get_memberships):
+        mock_get_memberships.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Access denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_memberships()
+
+        self.assertIn("Error received while retrieving memberships", str(context.exception))
+        mock_get_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_memberships")
+    def test_get_project_memberships(self, mock_get_project_memberships):
+        mock_response = ProjectMembershipsResponse(count=0, pages=0, projects=[])
+        mock_get_project_memberships.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_memberships_response', return_value=mock_response):
+            response = self.manager.get_project_memberships()
+
+        self.assertIsInstance(response, ProjectMembershipsResponse)
+        self.assertEqual(response.count, 0)
+        mock_get_project_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_memberships")
+    def test_get_project_memberships_error(self, mock_get_project_memberships):
+        mock_get_project_memberships.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Access denied"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_memberships()
+
+        self.assertIn("Error received while retrieving project memberships", str(context.exception))
+        mock_get_project_memberships.assert_called_once_with(email=None, start_page=1, page_size=20, order_key=None, order_direction="desc", role_types=None)
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_roles")
+    def test_get_project_roles(self, mock_get_project_roles):
+        mock_response = ProjectRolesResponse(roles=[])
+        mock_get_project_roles.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_roles_response', return_value=mock_response):
+            response = self.manager.get_project_roles("proj-123")
+
+        self.assertIsInstance(response, ProjectRolesResponse)
+        self.assertEqual(response.roles, [])
+        mock_get_project_roles.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_roles")
+    def test_get_project_roles_error(self, mock_get_project_roles):
+        mock_get_project_roles.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_roles("proj-123")
+
+        self.assertIn("Error received while retrieving project roles", str(context.exception))
+        mock_get_project_roles.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_members")
+    def test_get_project_members(self, mock_get_project_members):
+        mock_response = ProjectMembersResponse(members=[])
+        mock_get_project_members.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_project_members_response', return_value=mock_response):
+            response = self.manager.get_project_members("proj-123")
+
+        self.assertIsInstance(response, ProjectMembersResponse)
+        self.assertEqual(response.members, [])
+        mock_get_project_members.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_project_members")
+    def test_get_project_members_error(self, mock_get_project_members):
+        mock_get_project_members.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Project not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_project_members("proj-123")
+
+        self.assertIn("Error received while retrieving project members", str(context.exception))
+        mock_get_project_members.assert_called_once_with(project_id="proj-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_organization_members")
+    def test_get_organization_members(self, mock_get_organization_members):
+        mock_response = OrganizationMembersResponse(members=[])
+        mock_get_organization_members.return_value = {}
+
+        with patch.object(OrganizationResponseMapper, 'map_to_organization_members_response', return_value=mock_response):
+            response = self.manager.get_organization_members("org-123")
+
+        self.assertIsInstance(response, OrganizationMembersResponse)
+        self.assertEqual(response.members, [])
+        mock_get_organization_members.assert_called_once_with(organization_id="org-123")
+
+    @patch("pygeai.organization.clients.OrganizationClient.get_organization_members")
+    def test_get_organization_members_error(self, mock_get_organization_members):
+        mock_get_organization_members.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Organization not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_organization_members("org-123")
+
+        self.assertIn("Error received while retrieving organization members", str(context.exception))
+        mock_get_organization_members.assert_called_once_with(organization_id="org-123")

pygeai/tests/proxy/test_clients.py

@@ -247,6 +247,7 @@ class TestProxyClient(unittest.TestCase):
         """Test successful request."""
         mock_response = Mock()
         mock_response.json.return_value = {"status": "success"}
+        mock_response.status_code = 200
         mock_response.raise_for_status.return_value = None
         mock_session.return_value.request.return_value = mock_response
         
@@ -311,6 +312,7 @@ class TestProxyClient(unittest.TestCase):
         mock_response = Mock()
         mock_response.json.side_effect = ValueError("Invalid JSON")
         mock_response.text = "plain text response"
+        mock_response.status_code = 200
         mock_response.raise_for_status.return_value = None
         mock_session.return_value.request.return_value = mock_response
         

pygeai/tests/proxy/test_integration.py

@@ -230,6 +230,7 @@ class TestProxyIntegration(unittest.IsolatedAsyncioTestCase):
         # Mock response
         mock_response = Mock()
         mock_response.json.return_value = {"status": "success", "data": "test_data"}
+        mock_response.status_code = 200
         mock_response.raise_for_status.return_value = None
         mock_session.return_value.request.return_value = mock_response
         

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_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_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/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/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/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}")