pygeai 0.2.7b36__py3-none-any.whl → 0.2.7b38__py3-none-any.whl

pygeai/organization/responses.py

@@ -22,3 +22,26 @@ class ProjectTokensResponse(BaseModel):
 
 class ProjectItemListResponse(BaseModel):
     items: list[RequestItem]
+
+    def to_list(self):
+        return [item.to_dict() for item in self.items] if self.items else []
+
+    def __getitem__(self, index: int) -> RequestItem:
+        if self.items is None:
+            raise IndexError("ProjectItemListResponse is empty")
+        return self.items[index]
+
+    def __len__(self) -> int:
+        return len(self.items) if self.items else 0
+
+    def __iter__(self):
+        """Make ProjectItemListResponse iterable over its items."""
+        if self.items is None:
+            return iter([])
+        return iter(self.items)
+
+    def append(self, item: RequestItem) -> None:
+        """Append an Agent instance to the items list."""
+        if self.items is None:
+            self.items = []
+        self.items.append(item)

pygeai/tests/health/test_clients.py

@@ -0,0 +1,40 @@
+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
+
+        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/lab/agents/test_create_agent.py

@@ -4,6 +4,7 @@ import uuid
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model, Sampling, PromptExample, PromptOutput
 from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIError, InvalidAPIResponseException 
 
 
 class TestAILabCreateAgentIntegration(TestCase):    
@@ -23,7 +24,9 @@ class TestAILabCreateAgentIntegration(TestCase):
         This can be used to delete the created agent or reset the state.
         """
         if isinstance(self.created_agent, Agent):
-            self.ai_lab_manager.delete_agent(self.project_id, self.created_agent.id)
+            #TODO: Remove exception catch when delete_agent stop returning an unexpected error
+            with self.assertRaises(InvalidAPIResponseException) as e:
+                self.ai_lab_manager.delete_agent(self.project_id, self.created_agent.id)
 
 
     def __load_agent(self):
@@ -151,11 +154,12 @@ class TestAILabCreateAgentIntegration(TestCase):
                 self.new_agent = Agent(
                     name=str(uuid.uuid4())
                 )
-                self.created_agent = self.__create_agent(automatic_publish=auto_publish)
-        
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+
                 #TODO: Change validation error to a more specific one
-                self.assertEqual(self.created_agent.id, 400)
-                self.assertEqual(self.created_agent.description, "Bad Request")
+                self.assertIn("400",str(exception.exception))    
+                self.assertIn("Bad Request",str(exception.exception))
 
 
     def test_create_agent_no_name(self):
@@ -164,11 +168,12 @@ class TestAILabCreateAgentIntegration(TestCase):
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
                 self.new_agent.name = ""
-                self.created_agent = self.__create_agent(automatic_publish=auto_publish)
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
 
-                self.assertEqual(
-                    self.created_agent.errors[0].description,
+                self.assertIn(
                     "Agent name cannot be empty.",
+                    str(exception.exception),
                     f"Expected an error about the missing agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
@@ -180,12 +185,11 @@ class TestAILabCreateAgentIntegration(TestCase):
 
             with self.subTest(input=auto_publish):
                 self.new_agent.name = "AritmeticaExpert"
-
-                self.created_agent = self.__create_agent(automatic_publish=auto_publish)
-
-                self.assertEqual(
-                    self.created_agent.errors[0].description,
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+                self.assertIn(
                     "Agent cannot be created as it already exists [name=AritmeticaExpert].",
+                    str(exception.exception),                    
                     f"Expected an error about duplicated agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
@@ -194,26 +198,25 @@ class TestAILabCreateAgentIntegration(TestCase):
         test_params = [ True, False ]
 
         for auto_publish in test_params:
-
             with self.subTest(input=auto_publish):
                 new_agent = self.__load_agent()
                 new_agent2 = self.__load_agent()
-        
-                new_agent.name = f"{new_agent.name}:invalid"
-                result = self.__create_agent(agent=new_agent, automatic_publish=auto_publish)
 
-                new_agent2.name = f"{new_agent2.name}/invalid"
-                result2 = self.__create_agent(agent=new_agent2, automatic_publish=auto_publish)
-
-                self.assertEqual(
-                    result.errors[0].description,
+                with self.assertRaises(APIError) as exception:
+                    new_agent.name = f"{new_agent.name}:invalid"
+                    self.__create_agent(agent=new_agent, automatic_publish=auto_publish)
+                self.assertIn(
                     "Invalid character in name (: is not allowed).",
+                    str(exception.exception),                    
                     f"Expected an error about invalid character (:) in agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
-                self.assertEqual(
-                    result2.errors[0].description,
+                with self.assertRaises(APIError) as exception:
+                    new_agent2.name = f"{new_agent2.name}/invalid"
+                    self.__create_agent(agent=new_agent2, automatic_publish=auto_publish)
+                self.assertIn(
                     "Invalid character in name (/ is not allowed).",
+                    str(exception.exception),                    
                     f"Expected an error about invalid character (/) in agent name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
         
@@ -243,11 +246,11 @@ class TestAILabCreateAgentIntegration(TestCase):
 
             with self.subTest(input=auto_publish):
                 self.new_agent.public_name = None
-                self.created_agent = self.__create_agent(automatic_publish=auto_publish)
-
-                self.assertEqual(
-                    self.created_agent.errors[0].description,
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
+                self.assertIn(
                     "Agent publicName is required for agents with accessScope=public.",
+                    str(exception.exception),                    
                     f"Expected an error about missing publicName for public access scope with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
@@ -258,11 +261,12 @@ class TestAILabCreateAgentIntegration(TestCase):
         for auto_publish in test_params:
             with self.subTest(input=auto_publish): 
                 self.new_agent.public_name = self.new_agent.public_name.replace("_", "#")  # Add invalid character to public name
-                self.created_agent = self.__create_agent(automatic_publish=auto_publish)
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(automatic_publish=auto_publish)
 
-                self.assertEqual(
-                    self.created_agent.errors[0].description,
+                self.assertIn(
                     "Invalid public name, it can only contain lowercase letters, numbers, periods (.), dashes (-), and underscores (_). Please remove any other characters.",
+                    str(exception.exception),                    
                     f"The expected error about invalid publicName was not returned when autopublish is {'enabled' if auto_publish else 'disabled'}"
                 )
 
@@ -275,11 +279,12 @@ class TestAILabCreateAgentIntegration(TestCase):
             with self.subTest(input=auto_publish):
                 duplicated_pn_agent = self.__load_agent()
                 duplicated_pn_agent.public_name = self.created_agent.public_name
-                result = self.__create_agent(agent=duplicated_pn_agent, automatic_publish=auto_publish)
 
-                self.assertEqual(
-                    result.errors[0].description,
+                with self.assertRaises(APIError) as exception:
+                    self.__create_agent(agent=duplicated_pn_agent, automatic_publish=auto_publish)
+                self.assertIn(
                     f"Agent already exists [publicName={self.created_agent.public_name}].",
+                    str(exception.exception),                   
                     f"Expected an error about the duplicated public name when autopublish is {'enabled' if auto_publish else 'disabled'}"
                 )
 

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

@@ -0,0 +1,101 @@
+from unittest import TestCase
+import unittest
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import SharingLink
+from pygeai.core.common.exceptions import MissingRequirementException
+
+ai_lab_manager: AILabManager
+
+class TestAILabCreateSharingLinkIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.project_id = "be4889df-cacc-4e6f-b3bb-153c4ac0d168"
+        self.agent_id = "0026e53d-ea78-4cac-af9f-12650e5bb6d9" 
+
+    def __create_sharing_link(self, agent_id=None, project_id=None):
+        return self.ai_lab_manager.create_sharing_link(
+            project_id=self.project_id if project_id is None else project_id,
+            agent_id=self.agent_id if agent_id is None else agent_id
+        )
+    
+
+    def test_create_sharing_link(self):    
+        shared_link = self.__create_sharing_link()        
+        self.assertIsInstance(shared_link, SharingLink, "Expected response to be an instance of SharingLink")
+       
+        self.assertEqual(
+            shared_link.agent_id,
+            self.agent_id,
+            "Returned agentId should match the requested agent_id"
+        )
+        self.assertTrue(
+            shared_link.api_token.startswith("shared-"),
+            "apiToken should start with 'shared-'"
+        )
+        self.assertTrue(
+            shared_link.shared_link.startswith("https://"),
+            "sharedLink should be a valid URL"
+        )
+        self.assertIn(
+            f"agentId={self.agent_id}",
+            shared_link.shared_link,
+            "sharedLink should contain the agentId as a query parameter"
+        )
+        self.assertIn(
+            f"sharedToken={shared_link.api_token}",
+            shared_link.shared_link,
+            "sharedLink should contain the apiToken as sharedToken"
+        )
+
+
+    def test_create_sharing_link_no_project(self):
+        with self.assertRaises(MissingRequirementException) as context:
+            self.__create_sharing_link(project_id="")
+        self.assertEqual(
+            str(context.exception),
+            "Cannot create sharing link without specifying project_id",
+            "Expected exception for missing project_id"
+        )
+
+
+    def test_create_sharing_link_no_agent_id(self):
+        with self.assertRaises(MissingRequirementException) as context:
+            self.__create_sharing_link(agent_id="")
+        self.assertEqual(
+            str(context.exception),
+            "agent_id must be specified in order to create sharing link",
+            "Expected exception for missing agent_id"
+        )
+
+    @unittest.skip("A descriptive error exception is expected")
+    def test_create_sharing_link_invalid_agent_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        shared_link = self.__create_sharing_link(agent_id=invalid_id)
+
+        """ self.assertEqual(
+            deleted_agent.content["messages"][0]["description"],
+            f"Agent not found [IdOrName= {invalid_id}].",
+            "Expected error message for invalid agent id"
+        ) """
+
+
+    def test_create_sharing_link_invalid_project_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        shared_link = self.__create_sharing_link(project_id=invalid_id)
+
+        self.assertIsInstance(shared_link, SharingLink, "Expected response to be an instance of SharingLink")
+       
+        self.assertEqual(
+            shared_link.agent_id,
+            self.agent_id,
+            "Returned agentId should match the requested agent_id"
+        )
+        self.assertTrue(
+            shared_link.api_token.startswith("shared-"),
+            "apiToken should start with 'shared-'"
+        )
+        self.assertTrue(
+            shared_link.shared_link.startswith("https://"),
+            "sharedLink should be a valid URL"
+        )

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

@@ -0,0 +1,100 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabDeleteAgentIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.project_id = "be4889df-cacc-4e6f-b3bb-153c4ac0d168"
+        
+
+    def __create_agent(self):
+        """
+        Helper to create an agent with the current project_id and ai_lab_manager.
+        If automatic_publish is None, do not pass it (useful for tests that omit it).
+        """
+        agent = Agent(
+            name=str(uuid.uuid4()),
+            description="Agent that translates from any language to english.",
+            agent_data=AgentData(
+                prompt=Prompt(
+                    instructions="the user will provide a text, you must return the same text translated to english",
+                    inputs=["text", "avoid slang indicator"]
+                ),
+                llm_config=LlmConfig(
+                    max_tokens=1800,
+                    timeout=0
+                ),
+                models=[Model(name="gpt-4-turbo-preview")]
+            )
+        )
+
+
+        return self.ai_lab_manager.create_agent(
+            project_id=self.project_id,
+            agent=agent
+        )
+
+    def __delete_agent(self, agent_id: str, project_id=None):
+        return self.ai_lab_manager.delete_agent(
+            project_id=self.project_id if project_id is None else project_id,
+            agent_id=agent_id
+        )
+    
+
+    def test_delete_agent(self):         
+        create_agent = self.__create_agent()     
+        deleted_agent = self.__delete_agent(agent_id=create_agent.id)
+
+        self.assertEqual(
+            deleted_agent.content,
+            "Agent deleted successfully",
+            "Expected confirmation message after deletion"            
+        )
+
+
+    def test_delete_agent_no_project(self):
+        create_agent = self.__create_agent()     
+        deleted_agent = self.__delete_agent(agent_id=create_agent.id, project_id="")
+
+        self.assertEqual(
+            deleted_agent.content,
+            "Agent deleted successfully",
+            "Expected confirmation message after deletion even with missing project_id"            
+        )
+
+
+    def test_delete_agent_no_agent_id(self):
+        with self.assertRaises(APIError) as exception:
+            self.__delete_agent(agent_id="")
+
+        self.assertIn("405",str(exception.exception))    
+        self.assertIn("Method Not Allowed",str(exception.exception))
+
+
+    def test_delete_agent_invalid_agent_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        deleted_agent = self.__delete_agent(agent_id=invalid_id)
+
+        self.assertEqual(
+            deleted_agent.content["messages"][0]["description"],
+            f"Agent not found [IdOrName= {invalid_id}].",
+            "Expected error message for invalid agent id"
+        )
+
+
+    def test_delete_agent_invalid_project_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        create_agent = self.__create_agent()     
+        deleted_agent = self.__delete_agent(agent_id=create_agent.id, project_id=invalid_id)
+
+        self.assertEqual(
+            deleted_agent.content,
+            "Agent deleted successfully",
+            "Expected confirmation message after deletion even with invalid project id"
+        )

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

@@ -1,7 +1,7 @@
 from unittest import TestCase
-import unittest
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Agent, FilterSettings
+from pygeai.core.common.exceptions import MissingRequirementException, APIError
 import copy
 
 ai_lab_manager: AILabManager
@@ -41,8 +41,13 @@ class TestAILabGetAgentIntegration(TestCase):
 
     
     def test_get_agent_no_project(self):
-        agent = self.__get_agent(project_id="")
-        self.assertIsInstance(agent, Agent, "Expected an agent") 
+        with self.assertRaises(MissingRequirementException) as excepcion:
+            self.__get_agent(project_id="")
+        self.assertIn(
+            "Cannot retrieve agent without specifying project_id",
+            str(excepcion.exception),
+            "Expected exception for missing project_id"
+        )
     
 
     def test_get_agent_no_agent_id(self):
@@ -57,11 +62,11 @@ class TestAILabGetAgentIntegration(TestCase):
 
     def test_get_agent_invalid_agent_id(self):
         invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
-        agent = self.__get_agent(agent_id=invalid_id)
-
-        self.assertEqual(
-            agent.errors[0].description,
+        with self.assertRaises(APIError) as context:
+            self.__get_agent(agent_id=invalid_id)
+        self.assertIn(
             f"Agent not found [IdOrName= {invalid_id}].",
+            str(context.exception),
             "Expected an error for invalid agent id"
         )
 

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

@@ -0,0 +1,139 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Agent, AgentData, Prompt, PromptOutput, PromptExample, LlmConfig, Sampling, Model
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabPublishAgentRevisionIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.project_id = "be4889df-cacc-4e6f-b3bb-153c4ac0d168"
+        self.agent_id = "b4b09935-2ad2-42c0-bd55-1ee6fa4b6034"
+
+    
+    def __publish_agent_revision(self,  revision: str, project_id=None, agent_id=None):
+        return self.ai_lab_manager.publish_agent_revision(
+            project_id=self.project_id if project_id is None else project_id,
+            agent_id=self.agent_id if agent_id is None else agent_id,
+            revision=revision
+        )
+    
+
+    def __load_agent(self):
+        random_str = str(uuid.uuid4())
+        agent = Agent(
+            id="b4b09935-2ad2-42c0-bd55-1ee6fa4b6034",
+            name=f"UpdatedAgent{random_str}",
+            access_scope="public",
+            public_name=f"public_{random_str}",
+            job_description=f"SummarizerAgent{random_str}",
+            avatar_image="https://www.shareicon.net/data/128x128/2016/11/09/851442_logo_512x512.png",
+            description=f"Agent that summarized documents. {random_str}",
+            agent_data=AgentData(
+                prompt=Prompt(
+                    instructions="the user will provide a document, you must return a summary of the document.",
+                    inputs=["text", "avoid slang indicator"],
+                    outputs=[
+                        PromptOutput(key="translated_text", description="translated text, with slang or not depending on the indication. in plain text.")
+                    ],
+                    examples=[
+                        PromptExample(input_data="hola mundo [no-slang]", output='{"translated_text":"hello world"}'),
+                        PromptExample(input_data="esto es una prueba pincheguey [keep-slang]", output='{"translated_text":"this is a test pal"}')
+                    ]
+                ),
+                llm_config=LlmConfig(
+                    max_tokens=1800,
+                    timeout=0,
+                    sampling=Sampling(temperature=0.3, top_k=0, top_p=0)
+                ),
+                models=[Model(name="openai/gpt-4-turbo-preview")]
+            )
+        )
+
+        return agent
+
+
+    def __update_agent(self):
+        """
+        Helper method to update agent and generate a new revision of it
+        """
+        agent = self.__load_agent()
+        return self.ai_lab_manager.update_agent(
+            project_id=self.project_id,
+            agent=agent,
+            automatic_publish=False, 
+            upsert=False
+        )    
+
+
+    def test_publish_agent_revision(self):
+        new_revision = (self.__update_agent()).revision
+        published_agent = self.__publish_agent_revision(revision=new_revision)
+
+        self.assertFalse(published_agent.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_agent.revision, new_revision, "Expected last revision to be published") 
+
+    
+    def test_publish_agent_earlier_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="1")
+        self.assertIn(
+            "There are newer published revisions.",
+            str(exception.exception),
+            "Expected error when trying to send a earlier revision"
+        )
+
+
+    def test_publish_agent_invalid_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="10000000")
+        self.assertIn(
+            "Invalid revision [rev=10000000]",
+            str(exception.exception),
+            "Expected error when trying to send a revision that does not exist"
+        )
+
+
+    def test_publish_agent_string_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="revision")
+        self.assertIn("Bad Request", str(exception.exception))
+        self.assertIn("400", str(exception.exception))
+
+
+    def test_publish_agent_invalid_agent_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="103", agent_id=invalid_id)
+        self.assertIn(
+            f"Agent not found [IdOrName= {invalid_id}].",
+            str(exception.exception),
+            "Expected error when sending and invalid agent id"
+        )
+
+    
+    def test_publish_agent_no_agent_id(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_agent_revision(revision="103", agent_id="")
+        self.assertIn("Not Found", str(exception.exception))
+        self.assertIn("404", str(exception.exception))
+
+
+    def test_publish_agent_invalid_project_id(self):
+        new_revision = (self.__update_agent()).revision
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        published_agent = self.__publish_agent_revision(revision=new_revision, project_id=invalid_id)
+
+        self.assertFalse(published_agent.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_agent.revision, new_revision, "Expected last revision to be published")
+
+
+    def test_publish_agent_no_project_id(self):
+        new_revision = (self.__update_agent()).revision
+        published_agent = self.__publish_agent_revision(revision=new_revision, project_id="")
+
+        self.assertFalse(published_agent.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_agent.revision, new_revision, "Expected last revision to be published")