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

pygeai/tests/gam/test_clients.py

@@ -0,0 +1,195 @@
+import unittest
+from unittest.mock import MagicMock
+from json import JSONDecodeError
+from pygeai.gam.clients import GAMClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException, MissingRequirementException
+
+
+class TestGAMClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.gam.test_clients.TestGAMClient
+    """
+    def setUp(self):
+        self.client = GAMClient(api_key="test_key", base_url="test_url", alias="test_alias")
+        self.client.api_service = MagicMock()
+        self.mock_response = MagicMock()
+        self.mock_response.json.return_value = {"status": "success"}
+        self.mock_response.text = "success text"
+        self.mock_response.status_code = 200
+        self.client.api_service.base_url = "https://api.example.com"
+
+    def test_generate_signing_url_success(self):
+        client_id = "test-client-id"
+        redirect_uri = "https://example.com/callback"
+        state = "random-state"
+        scope = "gam_user_data"
+        response_type = "code"
+
+        result = self.client.generate_signing_url(
+            client_id=client_id,
+            redirect_uri=redirect_uri,
+            scope=scope,
+            state=state,
+            response_type=response_type
+        )
+
+        expected_url = "https://api.example.com/oauth/gam/signin?response_type=code&client_id=test-client-id&redirect_uri=https://example.com/callback&state=random-state&scope=gam_user_data"
+        self.assertEqual(result, expected_url)
+
+    def test_generate_signing_url_missing_parameters(self):
+        with self.assertRaises(MissingRequirementException) as context:
+            self.client.generate_signing_url(client_id="", redirect_uri="https://example.com/callback", state="state")
+        self.assertEqual(str(context.exception), "client_id, redirect_uri, and state are required.")
+
+        with self.assertRaises(MissingRequirementException) as context:
+            self.client.generate_signing_url(client_id="id", redirect_uri="", state="state")
+        self.assertEqual(str(context.exception), "client_id, redirect_uri, and state are required.")
+
+        with self.assertRaises(MissingRequirementException) as context:
+            self.client.generate_signing_url(client_id="id", redirect_uri="uri", state="")
+        self.assertEqual(str(context.exception), "client_id, redirect_uri, and state are required.")
+
+    def test_get_access_token_success(self):
+        self.client.api_service.post.return_value = self.mock_response
+
+        result = self.client.get_access_token(
+            client_id="test-client-id",
+            client_secret="test-client-secret",
+            grant_type="password",
+            authentication_type_name="local",
+            scope="gam_user_data",
+            username="test-user",
+            password="test-pass",
+            initial_properties={"Company": "GeneXus"},
+            repository="test-repo",
+            request_token_type="OAuth"
+        )
+
+        self.client.api_service.post.assert_called_once()
+        data = self.client.api_service.post.call_args[1]['data']
+        self.assertEqual(data['client_id'], "test-client-id")
+        self.assertEqual(data['client_secret'], "test-client-secret")
+        self.assertEqual(data['grant_type'], "password")
+        self.assertEqual(data['authentication_type_name'], "local")
+        self.assertEqual(data['scope'], "gam_user_data")
+        self.assertEqual(data['username'], "test-user")
+        self.assertEqual(data['password'], "test-pass")
+        self.assertEqual(data['initial_properties'], {"Company": "GeneXus"})
+        self.assertEqual(data['repository'], "test-repo")
+        self.assertEqual(data['request_token_type'], "OAuth")
+        headers = self.client.api_service.post.call_args[1]['headers']
+        self.assertEqual(headers['Content-Type'], "application/x-www-form-urlencoded")
+        self.assertTrue(self.client.api_service.post.call_args[1]['form'])
+        self.assertEqual(result, {"status": "success"})
+
+    def test_get_access_token_minimal_data(self):
+        self.client.api_service.post.return_value = self.mock_response
+
+        result = self.client.get_access_token(
+            client_id="test-client-id",
+            client_secret="test-client-secret",
+            username="test-user",
+            password="test-pass"
+        )
+
+        self.client.api_service.post.assert_called_once()
+        data = self.client.api_service.post.call_args[1]['data']
+        self.assertEqual(data['client_id'], "test-client-id")
+        self.assertEqual(data['client_secret'], "test-client-secret")
+        self.assertEqual(data['username'], "test-user")
+        self.assertEqual(data['password'], "test-pass")
+        self.assertEqual(result, {"status": "success"})
+
+    def test_get_access_token_json_decode_error(self):
+        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        self.client.api_service.post.return_value = self.mock_response
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_access_token(
+                client_id="test-client-id",
+                client_secret="test-client-secret",
+                username="test-user",
+                password="test-pass"
+            )
+
+        self.assertIn("Unable to get access token", str(context.exception))
+        self.client.api_service.post.assert_called_once()
+
+    def test_get_user_info_success(self):
+        self.client.api_service.get.return_value = self.mock_response
+
+        result = self.client.get_user_info(
+            access_token="test-access-token"
+        )
+
+        self.client.api_service.get.assert_called_once()
+        headers = self.client.api_service.get.call_args[1]['headers']
+        self.assertEqual(headers['Authorization'], "test-access-token")
+        self.assertEqual(headers['Content-Type'], "application/x-www-form-urlencoded")
+        self.assertEqual(result, {"status": "success"})
+
+    def test_get_user_info_json_decode_error(self):
+        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        self.client.api_service.get.return_value = self.mock_response
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_user_info(
+                access_token="test-access-token"
+            )
+
+        self.assertIn("Unable to get user info", str(context.exception))
+        self.client.api_service.get.assert_called_once()
+
+    def test_refresh_access_token_success(self):
+        self.client.api_service.post.return_value = self.mock_response
+
+        result = self.client.refresh_access_token(
+            client_id="test-client-id",
+            client_secret="test-client-secret",
+            grant_type="refresh_token",
+            refresh_token="test-refresh-token"
+        )
+
+        self.client.api_service.post.assert_called_once()
+        data = self.client.api_service.post.call_args[1]['data']
+        self.assertEqual(data['client_id'], "test-client-id")
+        self.assertEqual(data['client_secret'], "test-client-secret")
+        self.assertEqual(data['grant_type'], "refresh_token")
+        self.assertEqual(data['refresh_token'], "test-refresh-token")
+        headers = self.client.api_service.post.call_args[1]['headers']
+        self.assertEqual(headers['Content-Type'], "application/x-www-form-urlencoded")
+        self.assertTrue(self.client.api_service.post.call_args[1]['form'])
+        self.assertEqual(result, {"status": "success"})
+
+    def test_refresh_access_token_json_decode_error(self):
+        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        self.client.api_service.post.return_value = self.mock_response
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.refresh_access_token(
+                client_id="test-client-id",
+                client_secret="test-client-secret",
+                refresh_token="test-refresh-token"
+            )
+
+        self.assertIn("Unable to refresh access token", str(context.exception))
+        self.client.api_service.post.assert_called_once()
+
+    def test_get_authentication_types_success(self):
+        self.client.api_service.get.return_value = self.mock_response
+
+        result = self.client.get_authentication_types()
+
+        self.client.api_service.get.assert_called_once()
+        self.assertEqual(result, {"status": "success"})
+
+    def test_get_authentication_types_json_decode_error(self):
+        self.mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        self.client.api_service.get.return_value = self.mock_response
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.get_authentication_types()
+
+        self.assertIn("Unable to get authentication types", str(context.exception))
+        self.client.api_service.get.assert_called_once()
+

pygeai/tests/health/test_clients.py

@@ -0,0 +1,41 @@
+import unittest
+from json import JSONDecodeError
+from unittest.mock import patch
+
+from pygeai.core.common.exceptions import InvalidAPIResponseException
+from pygeai.health.clients import HealthClient
+from pygeai.health.endpoints import STATUS_CHECK_V1
+
+
+class TestHealthClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.health.test_clients.TestHealthClient
+    """
+
+    def setUp(self):
+        self.client = HealthClient()
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_check_api_status_success(self, mock_get):
+        expected_response = {"status": "healthy", "version": "1.0.0"}
+        mock_response = mock_get.return_value
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+
+        result = self.client.check_api_status()
+
+        self.assertEqual(result, expected_response)
+        mock_get.assert_called_once_with(endpoint=STATUS_CHECK_V1)
+
+    @patch("pygeai.core.services.rest.ApiService.get")
+    def test_check_api_status_json_decode_error(self, mock_get):
+        mock_response = mock_get.return_value
+        mock_response.status_code = 200
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = "Invalid JSON response"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.check_api_status()
+
+        self.assertEqual(str(context.exception), "Unable to check API status: Invalid JSON response")
+        mock_get.assert_called_once_with(endpoint=STATUS_CHECK_V1)

pygeai/tests/integration/assistants/rag/test_create_rag.py

@@ -0,0 +1,91 @@
+from unittest import TestCase
+import uuid
+from pygeai.assistant.managers import AssistantManager
+from pygeai.core.models import WelcomeData, LlmSettings
+from pygeai.assistant.rag.models import (
+    Search,
+    RetrieverOptions,
+    SearchOptions,
+    ChunkOptions,
+    IndexOptions,
+    RAGAssistant,
+)
+
+
+class TestAssistantCreateRagIntegration(TestCase):
+
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.assistant_manager = AssistantManager()
+
+        self.new_rag = self.__load_rag()
+        self.created_rag: RAGAssistant = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created tool
+        """
+        if isinstance(self.created_rag, RAGAssistant):
+            self.assistant_manager.delete_assistant(assistant_name=self.created_rag.name)            
+
+
+    def __load_rag(self):
+        llm_options = LlmSettings(
+            cache=False,
+            temperature=0.1,
+            max_tokens=999,
+            model_name="gpt-3.5-turbo-16k",
+            n=1,
+            presence_penalty=0,
+            frequency_penalty=0,
+            provider="OpenAI",
+            stream=False,
+            top_p=1.0,
+            type=None,
+            verbose=True,
+        )
+
+        retriever_options = RetrieverOptions(type="vectorStore")
+
+        search_options = SearchOptions(
+            history_count=2,
+            llm=llm_options,
+            search=Search(
+                k=5,
+                return_source_documents=False,
+                score_threshold=0,
+                prompt="Use {context} and {question}",
+                template="",
+            ),
+            retriever=retriever_options,
+        )
+
+        chunk_options = ChunkOptions(chunk_size=999, chunk_overlap=0)
+
+        index_options = IndexOptions(chunks=chunk_options)
+
+        welcome_data = WelcomeData(
+            title="Test Profile Welcome Data",
+            description="Test Profile with WelcomeData",
+            features=[],
+            examples_prompt=[],
+        )
+
+        return RAGAssistant(
+            name=str(uuid.uuid4()),
+            description="Test Profile with WelcomeData",
+            search_options=search_options,
+            index_options=index_options,
+            welcome_data=welcome_data,
+        )
+
+
+    def test_create_rag_assistant(self):
+        rag_assistant = self.__load_rag()
+        self.created_rag = self.assistant_manager.create_assistant(rag_assistant)
+
+        self.assertIsInstance(self.created_rag, RAGAssistant, "Failed to create RAG assistant")

pygeai/tests/integration/chat/test_generate_image.py

@@ -0,0 +1,158 @@
+from unittest import TestCase
+from pygeai.chat.clients import ChatClient
+
+chat_client: ChatClient
+
+class TestChatGenerateImageIntegration(TestCase):    
+
+    def setUp(self):
+        self.chat_client = ChatClient()
+        self.new_image = self.__load_image()
+
+
+    def __load_image(self):
+        return {
+            "model": "openai/gpt-image-1",
+            "prompt": "generate an image of a futuristic city skyline at sunset",
+            "n": 1,
+            "quality": "high",
+            "size": "1024x1536"
+        }
+    
+
+    def __generate_image(self, image = None):
+        image = image if image is not None else self.new_image
+        return self.chat_client.generate_image(
+            model=image["model"],
+            prompt=image["prompt"],
+            n=image["n"],
+            quality=image["quality"],
+            size=image["size"],
+            aspect_ratio= image["aspect_ratio"] if "aspect_ratio" in image else None
+        )
+
+    
+    def test_generate_image(self):
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 1, "Expected an image to be generated")
+
+
+    def test_generate_image_invalid_model(self):
+        self.new_image["model"] = "openai/gpt-image-10",
+        created_image = self.__generate_image()
+
+        self.assertEqual(
+            created_image["error"]["code"], 400,
+            "Expected a 400 code for invalid model"
+        )
+        self.assertEqual(
+            created_image["error"]["message"],
+            'Provider \'["openai\' does not exists.', 
+            "Expected an error message when model does not exists"
+        )
+
+
+    def test_generate_image_no_model(self):
+        self.new_image["model"] = ""
+        created_image = self.__generate_image()
+
+        self.assertEqual(
+            created_image["error"]["message"],
+            "LLM Provider NOT provided. Pass in the LLM provider you are trying to call", 
+            "Expected an error message when no model is provided"
+        )
+
+
+    def test_generate_image_no_prompt(self):
+        self.new_image["prompt"] = ""
+        created_image = self.__generate_image()
+
+        self.assertEqual(
+            created_image["error"]["type"],
+            "invalid_request_error",
+            "Expected a 400 code for no model"
+        )
+        self.assertEqual(
+            created_image["error"]["param"], "prompt", 
+            "Expected an error message when no model is provided"
+        )
+
+
+    def test_generate_image_specific_n(self):
+        self.new_image["n"] = 2
+
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 2, "Expected two images to be generated")
+
+
+    def test_generate_image_no_n(self):
+        self.new_image["n"] = None # default is 1
+
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 1, "Expected an image to be generated")
+
+
+    def test_generate_image_no_supported_n(self):
+        self.new_image["model"] = "openai/dall-e-3"
+        self.new_image["n"] = 5
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid 'n': integer above maximum value",
+            created_image["error"]["message"],
+            "Expected an error message when n is not supported by the model"
+        )
+
+
+    def test_generate_image_no_quality(self):
+        self.new_image["quality"] = ""
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid value: ''. Supported values are: 'low', 'medium', 'high', and 'auto'",
+            created_image["error"]["message"],
+            "Expected an error message when quality is not provided"
+        )
+    
+
+    def test_generate_image_no_supported_quality(self):
+        self.new_image["model"] = "openai/dall-e-3"
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid value: 'high'. Supported values are: 'standard' and 'hd'",
+            created_image["error"]["message"],
+            "Expected an error message when quality is not supported by the model"
+        )
+
+
+    def test_generate_image_no_size(self):
+        self.new_image["size"] = ""
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid value: ''. Supported values are: '1024x1024', '1024x1536', '1536x1024', and 'auto'",
+            created_image["error"]["message"],
+            "Expected an error message when no size is provided"
+        )
+
+
+    def test_generate_image_no_supported_size(self):
+        self.new_image["size"] = 1024
+        self.new_image["quality"] = None
+
+        created_image = self.__generate_image()
+        self.assertIn(
+            "Invalid type for 'size': expected one of '1024x1024', '1024x1536', '1536x1024', or 'auto', but got an integer instead",
+            created_image["error"]["message"],
+            "Expected an error message when no size is provided"
+        )
+    
+
+    def test_generate_image_with_aspect_ratio(self):
+        self.new_image["model"] = "vertex_ai/imagen-3.0-generate-001"
+        self.new_image["aspect_ratio"] = "4:3"
+        self.new_image["quality"] = None
+
+        created_image = self.__generate_image()
+        self.assertEqual(len(created_image["data"]), 1, "Expected an image to be generated")

pygeai/tests/integration/lab/agents/test_agents_list.py

@@ -0,0 +1,106 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import AgentList, FilterSettings
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabAgentsListIntegration(TestCase):    
+    __required_attrs = [
+        'id', 'status', 'name', 'access_scope', 'public_name',
+        'avatar_image', 'description', 'job_description',
+        'is_draft', 'is_readonly', 'revision', 'version', 'agent_data'
+    ]
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.filter_settings = FilterSettings(
+            allow_external=False,
+            allow_drafts=True,
+            access_scope="private",
+        )
+
+
+    def __get_agent_list(self, filter_settings: FilterSettings = None):
+        return self.ai_lab_manager.get_agent_list(
+            filter_settings= self.filter_settings if filter_settings is None else filter_settings
+        )
+    
+    def test_get_public_agent_list(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "public"
+        result = self.__get_agent_list(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgentList, "Expected a list of agents")        
+        for agent in result.agents:            
+            for attr in self.__required_attrs:
+                self.assertTrue(
+                    hasattr(agent, attr),
+                    f"Agent should have an '{attr}' attribute"
+                )   
+            self.assertEqual(agent.access_scope, "public", "Expected all agents to be public")
+
+
+    def test_get_private_agent_list(self):        
+        result = self.__get_agent_list()
+
+        self.assertIsInstance(result, AgentList, "Expected a list of agents")        
+        for agent in result.agents:            
+            for attr in self.__required_attrs:
+                self.assertTrue(
+                    hasattr(agent, attr),
+                    f"Agent should have an '{attr}' attribute"
+                )   
+            self.assertEqual(agent.access_scope, "private", "Expected all agents to be private")
+
+    
+    def test_get_agent_list_by_invalid_status(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.status = "status_active"
+        result = self.__get_agent_list(filter_settings=filter_settings)       
+    
+        self.assertEqual(len(result.agents), 0, "Expected no agents with invalid status")
+
+    
+    def test_get_agent_list_including_draft(self):
+        result = self.__get_agent_list()
+
+        validated = any(agent.is_draft == True for agent in result.agents)        
+        self.assertTrue(
+            validated,
+            "Expected at least one agent to be a draft"
+        )
+
+    
+    def test_get_agent_list_no_draft(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = False
+
+        result = self.__get_agent_list(filter_settings=filter_settings)
+        
+        for agent in result.agents: 
+            self.assertFalse(agent.is_draft, "Expected no agents to be drafts")
+
+    
+    def test_get_agent_list_start_over_offset(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.start = 50
+
+        result = self.__get_agent_list(filter_settings=filter_settings)        
+        self.assertEqual(len(result.agents), 0, "Expected no agents when starting at offset over total count")
+
+    
+    def test_get_agent_list_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+
+        result = self.__get_agent_list(filter_settings=filter_settings)        
+        self.assertEqual(len(result.agents), filter_settings.count, "Expected number of agents to match the count filter")
+
+    
+    def test_get_agent_list_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 50
+
+        result = self.__get_agent_list(filter_settings=filter_settings)        
+        self.assertLessEqual(len(result.agents), filter_settings.count, "Expected number of agents to be less than or equal to the count filter")