pygeai 0.4.0b3__py3-none-any.whl → 0.5.0__py3-none-any.whl

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(alias="beta")
+        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_create_agent.py

@@ -33,7 +33,6 @@ class TestAILabCreateAgentIntegration(TestCase):
             access_scope="public",
             public_name=f"public_{random_str}",
             job_description="Translator",
-            avatar_image="https://www.shareicon.net/data/128x128/2016/11/09/851442_logo_512x512.png",
             description="Agent that translates from any language to english.",
             agent_data=AgentData(
                 prompt=Prompt(
@@ -142,7 +141,6 @@ class TestAILabCreateAgentIntegration(TestCase):
         self.assertEqual(prompt.inputs, agent.agent_data.prompt.inputs)
 
 
-    @unittest.skip("Skipping test due to mismatch in expected behavior")
     def test_create_agent_without_required_data(self):
         test_params = [ True, False ]
 
@@ -152,12 +150,19 @@ class TestAILabCreateAgentIntegration(TestCase):
                 self.new_agent = Agent(
                     name=str(uuid.uuid4())
                 )
-                with self.assertRaises(APIError) as exception:
-                    self.__create_agent(automatic_publish=auto_publish)
+                if 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.assertIn("400",str(exception.exception))    
-                self.assertIn("Bad Request",str(exception.exception))
+                    #TODO: Change validation error to a more specific one
+                    self.assertIn(
+                        "A valid prompt is required. To be valid, it must provide clear instructions to the model",
+                        str(exception.exception)
+                    )   
+                else:
+                    created_agent = self.__create_agent(automatic_publish=auto_publish)
+                    self.assertTrue(isinstance(created_agent, Agent), "Expected a created agent")
 
 
     def test_create_agent_no_name(self):
@@ -287,21 +292,18 @@ class TestAILabCreateAgentIntegration(TestCase):
                 )
 
     
-    @unittest.skip("Agent is getting created regardless of the prompt instructions being empty")
     def test_create_agent_no_prompt_instructions(self):
         self.new_agent.agent_data.prompt.instructions = ""
-        with self.assertRaises(ValidationError) as exception:
-            self.__create_agent()
-        self.assertIn(
-            "instructions",
-            str(exception.exception),
-            "Expected a validation error about allowed values for instructions"
-        )
+        self.created_agent = self.__create_agent()
 
-        self.assertIn(
-            "Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]",
-            str(exception.exception),
-            "Expected a validation error about allowed values for instructions"
+        self.assertTrue(
+            isinstance(self.created_agent, Agent),
+            "Expected a created agent"
+        )
+        
+        self.assertIsNone(
+            self.created_agent.agent_data.prompt.instructions,
+            "Expected the created agent to not have prompt instructions"
         )
 
     

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

@@ -1,4 +1,5 @@
 from unittest import TestCase
+import unittest
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import SharingLink
 from pygeai.core.common.exceptions import APIError, MissingRequirementException
@@ -16,7 +17,7 @@ class TestAILabCreateSharingLinkIntegration(TestCase):
             agent_id=self.agent_id if agent_id is None else agent_id
         )
     
-
+    @unittest.skip("Endpoint is not found. Validate if it was deleted")
     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")
@@ -46,6 +47,7 @@ class TestAILabCreateSharingLinkIntegration(TestCase):
         )
 
 
+    @unittest.skip("Endpoint is not found. Validate if it was deleted")
     def test_create_sharing_link_no_agent_id(self):
         with self.assertRaises(MissingRequirementException) as context:
             self.__create_sharing_link(agent_id="")
@@ -56,6 +58,7 @@ class TestAILabCreateSharingLinkIntegration(TestCase):
         )
 
 
+    @unittest.skip("Endpoint is not found. Validate if it was deleted")
     def test_create_sharing_link_invalid_agent_id(self):
         with self.assertRaises(APIError) as exception:
             invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"

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

@@ -28,7 +28,6 @@ class TestAILabPublishAgentRevisionIntegration(TestCase):
             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(

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

@@ -25,7 +25,6 @@ class TestAILabUpdateAgentIntegration(TestCase):
             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(
@@ -192,43 +191,32 @@ class TestAILabUpdateAgentIntegration(TestCase):
         self.agent_to_update.agent_data.prompt.instructions = ""
 
         for auto_publish in test_params:
-            with self.subTest(input=auto_publish): 
-                with self.assertRaises(ValidationError) as exception:
-                    self.__update_agent(automatic_publish=auto_publish)
-                
-                self.assertIn(
-                    "instructions",
-                    str(exception.exception),
-                    f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
-                )
-                self.assertIn(
-                    "Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]",
-                    str(exception.exception),
-                    f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
-                )
+            with self.subTest(input=auto_publish):
+                if auto_publish == True:
+                    with self.assertRaises(ValidationError) as exception:
+                        self.__update_agent(automatic_publish=auto_publish)
+                    self.assertIn(
+                        "agent_data.prompt must have at least instructions for publication",
+                        str(exception.exception),
+                        f"Expected a validation error about allowed values for instructions when autopublish is {'enabled' if auto_publish else 'disabled'}"
+                    )
+                else:
+                    updated_agent = self.__update_agent(automatic_publish=auto_publish)
+                    self.assertTrue(isinstance(updated_agent, Agent))
 
-    
-    def test_update_agent_no_model(self):        
+
+    def test_update_agent_no_model(self):
         test_params = [ True, False ]
         self.agent_to_update.agent_data.models[0].name = ""
         
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
-                if auto_publish == False:
-                    with self.assertRaises(ValidationError) as exception:
-                        self.__update_agent(automatic_publish=auto_publish)
-                    error_msg = str(exception.exception)
+                
+                # If the agent is not published, the API returns a warning message for invalid model name. However, the sdk mapping is not returning it.
+                if auto_publish == False:                    
+                    updated_agent = self.__update_agent(automatic_publish=auto_publish)
                     
-                    self.assertIn(
-                        "name",
-                        error_msg,
-                        "Expected a validation error about empty model name" 
-                    )
-                    self.assertIn(
-                        "Input should be a valid string [type=string_type, input_value=None, input_type=NoneType]",
-                        error_msg,
-                        "Expected a validation error about empty model name" 
-                    )
+                    self.assertTrue(isinstance(updated_agent, Agent))
                 else:                 
                     with self.assertRaises(APIError) as exception:
                         self.__update_agent(automatic_publish=auto_publish)