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

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

@@ -0,0 +1,250 @@
+from unittest import TestCase
+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
+
+
+class TestAILabUpdateAgentIntegration(TestCase):    
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+
+        load_agent = self.__load_agent()
+        self.agent_to_update = load_agent["agent"]
+        self.random_str = load_agent["random_str"]
+
+    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}",
+            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-4o")]
+            )
+        )
+
+        return { 
+            "agent": agent,
+            "random_str": random_str 
+        }
+
+
+    def __update_agent(self, agent=None, automatic_publish=False, upsert=False):
+        """
+        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).
+        """
+        return self.ai_lab_manager.update_agent(
+            agent=self.agent_to_update if agent is None else agent,
+            automatic_publish=automatic_publish, 
+            upsert=upsert
+        )
+    
+
+    def test_update_agent(self):
+        self.agent_to_update.agent_data.models[0].name = "gemini/gemini-1.5-flash-8b-exp-0827"
+        self.agent_to_update.access_scope = "private"
+        updated_agent = self.__update_agent()
+
+        self.assertTrue(isinstance(updated_agent, Agent), "Expected a created agent")
+       
+        self.assertEqual(updated_agent.name, f"UpdatedAgent{self.random_str}")
+        self.assertEqual(updated_agent.access_scope, "private")
+        self.assertEqual(updated_agent.public_name, f"public_{self.random_str}")
+        self.assertEqual(updated_agent.job_description, f"SummarizerAgent{self.random_str}",)
+        self.assertEqual(updated_agent.description, f"Agent that summarized documents. {self.random_str}")
+
+        self.assertEqual(updated_agent.agent_data.models[0].name, "gemini/gemini-1.5-flash-8b-exp-0827")
+        self.assertTrue(updated_agent.is_draft, "gemini/gemini-1.5-flash-8b-exp-0827")
+
+        self.agent_to_update.agent_data.models[0].name = "openai/gpt-4o"
+        self.__update_agent()
+
+    
+    def test_update_agent_no_name(self):
+        test_params = [ True, False ]
+        self.agent_to_update.name = ""
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "Error received while updating agent: errors=[Error(id=2007, description='Agent name cannot be empty.')]",
+                    str(exception.exception),
+                    f"Expected error about missing agent name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+
+
+    def test_update_agent_duplicated_name(self):
+        test_params = [ True, False ]
+        self.agent_to_update.name = "AritmeticaExpert"
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "Agent already exists [name=AritmeticaExpert].",
+                    str(exception.exception),
+                    f"Expected error about duplicated agent name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+
+    
+    def test_update_agent_invalid_name(self):
+        test_params = [ True, False ]
+        self.agent_to_update.name = f"{self.agent_to_update.name}:/"
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Invalid character in name (: is not allowed).",
+                    str(exception.exception),
+                    f"Expected error about invalid character (:) in name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+                self.assertIn(
+                    "Invalid character in name (/ is not allowed).",
+                    str(exception.exception),
+                    f"Expected error about invalid character (/) in name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+
+
+    def test_update_agent_no_public_name(self):        
+        test_params = [ True, False ]
+        self.agent_to_update.public_name = ""
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Agent publicName is required for agents with accessScope=public.",
+                    str(exception.exception),
+                    f"Expected error about missing public name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+
+
+    def test_update_agent_duplicated_public_name(self):               
+        test_params = [ True, False ]
+        self.agent_to_update.public_name = "com.testing.geai.googlesummarizer"
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish): 
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Agent already exists [publicName=com.testing.geai.googlesummarizer].",
+                    str(exception.exception),
+                    f"Expected error about duplicated public name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+
+    
+    def test_update_agent_invalid_public_name(self):        
+        test_params = [ True, False ]
+        self.agent_to_update.public_name = self.agent_to_update.public_name.replace("_", "/")
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish): 
+                with self.assertRaises(APIError) as exception:
+                    self.__update_agent(automatic_publish=auto_publish)
+
+                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"Expected error about invalid public name when autopublish is {'enabled' if auto_publish else 'disabled'} was not returned."
+                )
+
+
+    def test_update_agent_no_prompt_instructions(self):
+        test_params = [ True, False ]
+        self.agent_to_update.agent_data.prompt.instructions = ""
+
+        for auto_publish in test_params:
+            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):
+        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 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.assertTrue(isinstance(updated_agent, Agent))
+                else:                 
+                    with self.assertRaises(APIError) as exception:
+                        self.__update_agent(automatic_publish=auto_publish)
+                    error_msg = str(exception.exception)
+                    self.assertIn(
+                        "description='Model not found [name=]",
+                        error_msg,
+                        "Expected a validation error about allowed values for model name" 
+                    )
+
+    
+    def test_update_agent_autopublish(self):        
+        updated_agent = self.__update_agent(automatic_publish=True)
+
+        self.assertEqual(
+            updated_agent.name, 
+            f"UpdatedAgent{self.random_str}",
+            "Expected agent name to remain unchanged after update."
+        )
+        self.assertFalse(
+            updated_agent.is_draft,
+            "Expected agent to be published when autopublish is True, but it is still a draft."
+        )
+
+
+    def test_update_agent_autopublish_private_scope(self):
+        self.agent_to_update.access_scope = "private"
+
+        updated_agent = self.__update_agent(automatic_publish=True)
+        self.assertFalse(updated_agent.is_draft, "Expected the agent to be published automatically even with private scope")
+    

pygeai/tests/integration/lab/processes/test_create_process.py

@@ -0,0 +1,345 @@
+from unittest import TestCase
+import unittest
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import (
+    AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, Task, 
+    UserSignal, Event, SequenceFlow, Variable
+)
+from pygeai.core.common.exceptions import APIResponseError, APIError
+
+
+class TestAILabCreateProcessIntegration(TestCase): 
+
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+        self.new_process = self.__load_process()
+        self.created_process: AgenticProcess = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created process
+        """
+        if isinstance(self.created_process, AgenticProcess):
+            self.ai_lab_manager.delete_process(self.created_process.id)
+
+
+    def __load_process(self):
+        """
+        Helper to load a complete process configuration for testing.
+        """
+        unique_key = str(uuid.uuid4())
+        process = AgenticProcess(
+            key="product_def",
+            name=f"Test Process {unique_key[:8]}",
+            description="This is a sample process",
+            kb=KnowledgeBase(name="basic-sample", artifact_type_name=["sample-artifact"]),
+            agentic_activities=[
+                AgenticActivity(key="activityOne", name="First Step", task_name="basic-task", agent_name="GoogleSummarizer2", agent_revision_id=0)
+            ],
+            artifact_signals=[
+                ArtifactSignal(key="artifact.upload.1", name="artifact.upload", handling_type="C", artifact_type_name=["sample-artifact"])
+            ],
+            user_signals=[
+                UserSignal(key="signal_done", name="process-completed")
+            ],
+            start_event=Event(key="artifact.upload.1", name="artifact.upload"),
+            end_event=Event(key="end", name="Done"),
+            sequence_flows=[
+                SequenceFlow(key="step1", source_key="artifact.upload.1", target_key="activityOne"),
+                SequenceFlow(key="step2", source_key="activityOne", target_key="signal_done"),
+                SequenceFlow(key="stepEnd", source_key="signal_done", target_key="end")
+            ]
+        )
+        return process
+    
+
+    def __create_process(self, process=None, automatic_publish=False):
+        """
+        Helper to create a process using ai_lab_manager.
+        """
+        return self.ai_lab_manager.create_process(
+            process=self.new_process if process is None else process,
+            automatic_publish=automatic_publish
+        )
+    
+
+    def test_create_process_full_data(self):
+        """
+        Test creating a process with all available fields populated.
+        """
+        self.created_process = self.__create_process()
+        created_process = self.created_process
+        process = self.new_process
+
+        self.assertTrue(isinstance(created_process, AgenticProcess), "Expected a created process")
+
+        # Assert the main fields of the created process
+        self.assertIsNotNone(created_process.id)
+        #self.assertEqual(created_process.key, process.key)
+        self.assertEqual(created_process.name, process.name)
+        self.assertEqual(created_process.description, process.description)
+        self.assertEqual(created_process.status, "active")
+
+        # Assert knowledge base
+        self.assertIsNotNone(created_process.kb)
+        self.assertEqual(created_process.kb.name, process.kb.name)
+
+        # Assert agentic activities
+        created_activity = created_process.agentic_activities[0]
+        original_activity = process.agentic_activities[0]
+        self.assertTrue(isinstance(created_activity, AgenticActivity)) 
+        self.assertEqual(created_activity.key.lower(), original_activity.key.lower())
+        self.assertEqual(created_activity.name, original_activity.name)
+            
+        # Assert artifact signals
+        created_signal = created_process.artifact_signals[0]
+        original_signal = process.artifact_signals[0]
+        self.assertTrue(isinstance(created_signal, ArtifactSignal))        
+        self.assertEqual(created_signal.key.lower(), original_signal.key.lower())
+        self.assertEqual(created_signal.name, original_signal.name)
+        self.assertEqual(created_signal.handling_type, original_signal.handling_type)
+
+        # Assert user signals
+        created_user_signal = created_process.user_signals[0]
+        self.assertTrue(isinstance(created_user_signal, UserSignal))
+
+        # Assert events
+        self.assertIsNotNone(created_process.start_event)
+        self.assertEqual(created_process.start_event.key.lower(), process.start_event.key.lower())
+        self.assertEqual(created_process.start_event.name, process.start_event.name)
+       
+        self.assertIsNotNone(created_process.end_event)
+        self.assertEqual(created_process.end_event.key.lower(), process.end_event.key.lower())
+        self.assertEqual(created_process.end_event.name, process.end_event.name)
+
+        # Assert sequence flows
+        created_flow = created_process.sequence_flows[0]
+        original_flow = process.sequence_flows[0]
+        self.assertIsNotNone(created_process.sequence_flows)
+        self.assertEqual(len(created_process.sequence_flows), len(process.sequence_flows))
+            
+        self.assertEqual(created_flow.key.lower(), original_flow.key.lower())
+        self.assertEqual(created_flow.source_key.lower(), original_flow.source_key.lower())
+        self.assertEqual(created_flow.target_key.lower(), original_flow.target_key.lower())
+
+
+    def test_create_process_minimum_required_data(self):
+        """
+        Test creating a process with only minimum required fields (key and name).
+        """
+        unique_key = str(uuid.uuid4())
+        self.new_process = AgenticProcess(
+            key=unique_key,
+            name=f"Minimal Process {unique_key[:8]}"
+        )
+        self.created_process = self.__create_process()
+        process = self.new_process
+
+        self.assertTrue(isinstance(self.created_process, AgenticProcess), "Expected a created process")
+        self.assertIsNotNone(self.created_process.id)
+        self.assertEqual(self.created_process.name, process.name)
+
+
+    def test_create_process_without_key(self):
+        """
+        Test creating a process without a key should still work (key is optional).
+        """
+        self.new_process = AgenticProcess(
+            name=f"Process Without Key {str(uuid.uuid4())[:8]}"
+        )
+        self.created_process = self.__create_process()
+
+        self.assertTrue(isinstance(self.created_process, AgenticProcess), "Expected a created process")
+        self.assertIsNotNone(self.created_process.id)
+        self.assertEqual(self.created_process.name, self.new_process.name)
+
+    
+    def test_create_process_no_name(self):
+        """
+        Test creating a process without a name should raise an error.
+        """
+        test_params = [True, False]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.new_process.name = ""
+                with self.assertRaises(APIError) as exception:
+                    self.__create_process(automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "Process name cannot be empty",
+                    str(exception.exception),
+                    f"Expected an error about empty process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+   
+    def test_create_process_duplicated_name(self):
+        """
+        Test creating a process with a duplicate name should raise an error.
+        """
+        test_params = [True, False]
+        created_process = self.__create_process()
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                loaded_process = self.__load_process()
+                loaded_process.name = created_process.name
+                with self.assertRaises(APIError) as exception:
+                    self.__create_process(process = loaded_process, automatic_publish=auto_publish)
+
+                self.assertIn(
+                    f"A process with this name already exists [name={created_process.name}].",
+                    str(exception.exception),
+                    f"Expected an error about duplicated process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_process_invalid_name_characters(self):
+        """
+        Test creating a process with invalid characters in name should raise a validation error.
+        """
+        test_params = [True, False]
+
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                invalid_names = [
+                    f"{str(uuid.uuid4())[:8]}:invalid",
+                    f"{str(uuid.uuid4())[:8]}/invalid"
+                ]
+
+                for invalid_name in invalid_names:
+                    new_process = self.__load_process()
+                    new_process.name = invalid_name
+                    
+                    with self.assertRaises(APIError) as exception:
+                        self.__create_process(process=new_process, automatic_publish=auto_publish)
+                    
+                    self.assertIn(
+                        "Invalid character in name",
+                        str(exception.exception),
+                        f"Expected an error about invalid character in process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                    )
+
+    
+    @unittest.skip("Skipping test for now.KB is required but is marked as optional")
+    def test_create_process_with_no_kb(self):
+        """
+        Test creating a process with knowledge base in JSON format.
+        """
+        unique_key = str(uuid.uuid4())
+        self.new_process.kb = None
+        self.created_process = self.__create_process()
+
+        self.assertIsNotNone(self.created_process.kb)
+        self.assertEqual(self.created_process.kb.name, "basic-sample")
+
+
+    def test_create_process_with_empty_agentic_activities_array(self):
+        """
+        Test creating a process with empty agentic activities array (to clear all activities).
+        """
+        self.new_process.agentic_activities = []
+        self.new_process.sequence_flows = [] # Clear sequence flows as well because they depend on activities
+        self.created_process = self.__create_process()
+
+        # Empty array should be handled gracefully
+        self.assertTrue(
+            self.created_process.agentic_activities is None or 
+            len(self.created_process.agentic_activities) == 0
+        )
+
+
+    def test_create_process_with_multiple_artifact_signals(self):
+        """
+        Test creating a process with multiple artifact signals.
+        """
+        self.new_process.artifact_signals=[
+            ArtifactSignal(key="artifact.upload.1", name="artifact.upload", handling_type="C", artifact_type_name=["sample-artifact"]),
+            ArtifactSignal(key="artifact.upload.2", name="artifact.upload.second", handling_type="C", artifact_type_name=["sample-artifact"])
+        ]
+        self.created_process = self.__create_process()
+
+        self.assertIsNotNone(self.created_process.artifact_signals)
+        self.assertEqual(len(self.created_process.artifact_signals), 2)
+
+        first_signal = self.created_process.artifact_signals[0]
+        second_signal = self.created_process.artifact_signals[1]
+        
+        self.assertEqual(first_signal.key.lower(), "artifact.upload.1")
+        self.assertEqual(second_signal.key.lower(), "artifact.upload.2")
+
+
+    def test_create_process_with_multiple_user_signals(self):
+        """
+        Test creating a process with multiple user signals.
+        """
+        self.new_process.user_signals=[
+            UserSignal(key="signal_done", name="process-completed"),
+            UserSignal(key="signal_cancel", name="process-cancelled")
+        ]
+        self.created_process = self.__create_process()
+
+        self.assertIsNotNone(self.created_process.user_signals)
+        self.assertEqual(len(self.created_process.user_signals)-1, 2)
+        keys = [signal.key for signal in self.created_process.user_signals]
+
+        assert "SIGNAL_CANCEL" in keys
+        assert "SIGNAL_DONE" in keys
+
+
+    def test_create_process_autopublish_disabled(self):
+        """
+        Test creating a process without automatic publish (default behavior).
+        """
+        self.created_process = self.__create_process(automatic_publish=False)
+        
+        # Process should be created as draft by default
+        self.assertTrue(
+            self.created_process.is_draft is True or 
+            self.created_process.is_draft is None,  # API might not return this field for drafts
+            "Expected the process to be created as draft when autopublish is disabled"
+        )
+
+   
+    def test_create_process_autopublish_without_task(self):
+        """
+        Test creating a process with automatic publish enabled.
+        """
+        
+        with self.assertRaises(APIError) as exception:
+            self.__create_process(automatic_publish=True)
+
+        self.assertIn(
+            "Failure on process publication",
+            str(exception.exception),
+            "Expected an error about failure on process publication"
+        )
+
+        self.assertIn(
+            "Task is required",
+            str(exception.exception),
+            "Expected an error about task being required"
+        )
+
+
+    def test_create_process_autopublish_enabled(self):
+        """
+        Test creating a process with automatic publish enabled.
+        """
+        unique_key = str(uuid.uuid4())
+        task = Task(name=unique_key, description="Basic task for process", title_template="Basic Task")
+        self.ai_lab_manager.create_task(task=task, automatic_publish=True)
+        self.new_process.agentic_activities[0].task_name = unique_key
+        
+       
+        self.created_process = self.__create_process(automatic_publish=True)
+        self.assertTrue(
+            self.created_process.is_draft is False,
+            "Expected the process to be created no draft when autopublish is enabled"
+        )