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

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

@@ -15,7 +15,7 @@ class TestAILabCreateProcessIntegration(TestCase):
         """
         Set up the test environment.
         """
-        self.ai_lab_manager = AILabManager(alias="beta")
+        self.ai_lab_manager = AILabManager()
         self.new_process = self.__load_process()
         self.created_process: AgenticProcess = None
 

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

@@ -0,0 +1,211 @@
+from unittest import TestCase
+import unittest
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Task, Prompt, ArtifactTypeList, ArtifactType
+from pygeai.core.common.exceptions import APIResponseError, APIError
+
+
+class TestAILabCreateTaskIntegration(TestCase): 
+
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager()
+        self.new_task = self.__load_task()
+        self.created_task: Task = None
+
+
+    def tearDown(self):
+        """
+        Clean up after each test if necessary.
+        This can be used to delete the created task
+        """
+        if isinstance(self.created_task, Task):
+            self.ai_lab_manager.delete_task(task_id=self.created_task.id)
+
+
+    def __load_task(self):
+        """
+        Helper to load a complete task configuration for testing.
+        """
+        unique_key = str(uuid.uuid4())
+        task = Task(
+            name=f"test_task_{unique_key[:8]}",
+            description=f"This is a sample task for testing 'test_task_{unique_key[:8]}'"
+        )
+        return task
+    
+
+    def __create_task(self, task=None, automatic_publish=False):
+        """
+        Helper to create a task using ai_lab_manager.
+        """
+        return self.ai_lab_manager.create_task(
+            task=self.new_task if task is None else task,
+            automatic_publish=automatic_publish
+        )
+    
+
+    def test_create_task(self):
+        """
+        Test creating a task with all available fields populated.
+        """
+        self.created_task = self.__create_task()
+        created_task = self.created_task
+        task = self.new_task
+
+        self.assertTrue(isinstance(created_task, Task), "Expected a created task")
+
+        # Assert the main fields of the created task
+        self.assertIsNotNone(created_task.id)
+        self.assertEqual(created_task.name, task.name)
+        self.assertEqual(created_task.description, task.description)
+
+        # Assert revision and status
+        self.assertEqual(self.created_task.revision, 1)
+        self.assertEqual(self.created_task.status, 'active')
+
+
+    def test_create_task_with_prompt_data(self):
+        """
+        Test creating a task with prompt data.
+        """
+        unique_key = str(uuid.uuid4())
+        self.new_task = task = Task(
+            name=f"test_task_{unique_key[:8]}",
+            description=f"This is a sample task for testing 'test_task_{unique_key[:8]}'",
+            title_template="Test Task: {{issue}}",
+            prompt_data=Prompt(
+                instructions="Analyze the provided data and generate a summary.",
+                inputs=["input_data"],
+                outputs=[]
+            )
+        )
+        self.created_task = self.__create_task()
+        
+        # Assert prompt data
+        self.assertIsNotNone(self.created_task.prompt_data)
+        self.assertEqual(self.created_task.prompt_data.instructions, "Analyze the provided data and generate a summary.")
+        self.assertEqual(self.created_task.prompt_data.inputs, ["input_data"])
+
+
+    def test_create_task_with_custom_id(self):
+        """
+        Test creating a task with a custom ID.
+        """
+        unique_key = str(uuid.uuid4())
+        custom_id = unique_key
+        self.new_task = Task(
+            name=f"task_with_custom_id_{unique_key[:8]}",
+            id=custom_id
+        )
+        self.created_task = self.__create_task()
+
+        self.assertTrue(isinstance(self.created_task, Task), "Expected a created task")
+        self.assertEqual(self.created_task.id, custom_id)
+
+
+    def test_create_task_empty_name(self):
+        """
+        Test creating a task with empty name should raise an error.
+        """
+        test_params = [True, False]
+
+        for auto_publish in test_params:
+            with self.subTest(auto_publish=auto_publish):
+                self.new_task.name = ""
+                with self.assertRaises((APIError, ValueError)) as exception:
+                    self.__create_task(automatic_publish=auto_publish)
+
+                self.assertTrue(
+                    "Task name cannot be empty" in str(exception.exception),
+                    f"Expected an error about empty task name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+   
+    def test_create_task_duplicated_name(self):
+        """
+        Test creating a task with a duplicate name should raise an error.
+        """
+        test_params = [True, False]
+        created_task = self.__create_task()
+
+        for auto_publish in test_params:
+            with self.subTest(auto_publish=auto_publish):
+                loaded_task = self.__load_task()
+                loaded_task.name = created_task.name
+                with self.assertRaises(APIError) as exception:
+                    self.__create_task(task=loaded_task, automatic_publish=auto_publish)
+
+                self.assertIn(
+                    "already exists",
+                    str(exception.exception).lower(),
+                    f"Expected an error about duplicated task name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+    
+    def test_create_task_invalid_name_characters(self):
+        """
+        Test creating a task with invalid characters in name should raise a validation error.
+        """
+        test_params = [True, False]
+
+        for auto_publish in test_params:
+            with self.subTest(auto_publish=auto_publish):
+                invalid_names = [
+                    f"task_{str(uuid.uuid4())[:8]}:invalid",
+                    f"task_{str(uuid.uuid4())[:8]}/invalid"
+                ]
+
+                for invalid_name in invalid_names:
+                    new_task = self.__load_task()
+                    new_task.name = invalid_name
+                    
+                    with self.assertRaises((APIError, ValueError)) as exception:
+                        self.__create_task(task=new_task, automatic_publish=auto_publish)
+                        
+                    self.assertTrue(
+                        f"Invalid character in name ({':' if ':' in invalid_name else '/'} is not allowed).",
+                        f"Expected an error about invalid character in task name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                    )
+
+
+    def test_create_task_autopublish_disabled(self):
+        """
+        Test creating a task without automatic publish (default behavior).
+        """
+        self.created_task = self.__create_task(automatic_publish=False)
+        
+        # Task should be created as draft by default
+        self.assertTrue(
+            self.created_task.is_draft is True or 
+            self.created_task.is_draft is None,
+            "Expected the task to be created as draft when autopublish is disabled"
+        )
+
+
+    def test_create_task_with_complex_prompt_data(self):
+        """
+        Test creating a task with complex prompt data including outputs.
+        """
+        unique_key = str(uuid.uuid4())
+        self.new_task = Task(
+            name=f"task_complex_prompt_{unique_key[:8]}",
+            prompt_data=Prompt(
+                instructions="Analyze the provided data and generate multiple outputs.",
+                inputs=["input_data", "parameters"],
+                outputs=[
+                    {"key": "summary", "description": "Data summary"},
+                    {"key": "analysis", "description": "Detailed analysis"}
+                ]
+            )
+        )
+        self.created_task = self.__create_task()
+
+        self.assertIsNotNone(self.created_task.prompt_data)
+        self.assertEqual(len(self.created_task.prompt_data.inputs), 2)
+        self.assertIn("input_data", self.created_task.prompt_data.inputs)
+        self.assertIn("parameters", self.created_task.prompt_data.inputs)
+    

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

@@ -0,0 +1,111 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, UserSignal, Event, SequenceFlow
+from pygeai.core.common.exceptions import InvalidAPIResponseException, MissingRequirementException
+from pygeai.core.base.responses import EmptyResponse
+
+ai_lab_manager: AILabManager
+
+class TestAILabDeleteProcessIntegration(TestCase):  
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        
+
+    def __create_process(self):
+        """
+        Helper to create a process with the current ai_lab_manager.
+        """
+        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 self.ai_lab_manager.create_process(
+            process=process,
+            automatic_publish=False
+        )
+    
+
+    def __delete_process(self, process_id: str = None, process_name: str = None):
+        return self.ai_lab_manager.delete_process(
+            process_id=process_id,
+            process_name=process_name
+        )
+    
+
+    def test_delete_process_by_id(self):         
+        created_process = self.__create_process()     
+        deleted_process = self.__delete_process(process_id=created_process.id)
+        print(deleted_process)
+
+        self.assertEqual(
+            deleted_process.content,
+            "Process deleted successfully",
+            "Expected confirmation message after deletion"            
+        )
+
+
+    def test_delete_process_by_name(self):         
+        created_process = self.__create_process()     
+        deleted_process = self.__delete_process(process_id="",process_name=created_process.name)
+
+        self.assertEqual(
+            deleted_process.content,
+            "Process deleted successfully",
+            "Expected confirmation message after deletion"            
+        )
+
+
+    def test_delete_process_no_parameters(self):
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__delete_process()
+        self.assertIn(
+            "Either process_id or process_name must be provided",
+            str(exception.exception),
+            "Expected error message for missing parameters"
+        )
+
+
+    def test_delete_process_invalid_process_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(InvalidAPIResponseException) as exception:
+            self.__delete_process(process_id=invalid_id)
+
+        self.assertIn(
+            f"Unable to delete process {invalid_id}",
+            str(exception.exception),
+            "Expected error message for invalid process id"
+        )
+
+
+    def test_delete_process_invalid_process_name(self):
+        invalid_name = "NonExistentProcessName123"
+        with self.assertRaises(InvalidAPIResponseException) as exception:
+            self.__delete_process(process_name=invalid_name)
+
+        self.assertIn(
+            f"Unable to delete process {invalid_name}",
+            str(exception.exception),
+            "Expected error message for invalid process name"
+        )

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

@@ -13,7 +13,7 @@ class TestAILabGetProcessIntegration(TestCase):
         """
         Set up the test environment.
         """
-        self.ai_lab_manager = AILabManager(alias="beta")
+        self.ai_lab_manager = AILabManager()
         self.process_id = "7e28e9ab-b9a2-417e-9e87-ed7f6ec9534b"
         self.process_name = "Test Process For Sdk Project"
         self.filter_settings = FilterSettings(

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

@@ -0,0 +1,91 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, ProcessInstanceList, AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, UserSignal, Event, SequenceFlow
+from pygeai.core.common.exceptions import APIError, MissingRequirementException
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListProcessInstancesIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        # Using a known process ID that should have instances for testing
+        self.process_id = "6c9c99a0-9eb1-4647-9f2f-886cf6a51ac0"
+        self.filter_settings = FilterSettings(
+            start=0,
+            count=10,
+            is_active=False
+        )
+
+
+    def __list_process_instances(self, process_id: str = None, filter_settings: FilterSettings = None):
+        process_id = process_id if process_id is not None else self.process_id
+        filter_settings = filter_settings if filter_settings is not None else self.filter_settings
+        return self.ai_lab_manager.list_process_instances(
+            process_id=process_id,
+            filter_settings=filter_settings
+        )
+    
+    
+    def test_default_list_process_instances(self):
+        result = self.__list_process_instances()
+        self.assertIsInstance(result, ProcessInstanceList, "Expected a ProcessInstanceList")
+
+
+    def test_list_process_instances_completed(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.status = "Completed"
+        result = self.__list_process_instances(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, ProcessInstanceList, "Expected a ProcessInstanceList")
+        if result.instances:
+            for instance in result.instances:
+                self.assertTrue(
+                    instance.status == 'Completed',
+                    "Expected all instances to be completed"
+                )
+
+
+    def test_list_process_instances_include_inactive(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.is_active = True
+        result = self.__list_process_instances(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, ProcessInstanceList, "Expected a ProcessInstanceList")
+
+
+    def test_list_process_instances_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+        result = self.__list_process_instances(filter_settings=filter_settings)
+        
+        self.assertIsInstance(result, ProcessInstanceList, "Expected a ProcessInstanceList")
+        self.assertLessEqual(
+            len(result.instances), 2,
+            "Expected list of process instances returned to be 2 or less"
+        )
+
+
+    def test_list_process_instances_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 50
+        result = self.__list_process_instances(filter_settings=filter_settings)
+        
+        self.assertIsInstance(result, ProcessInstanceList, "Expected a ProcessInstanceList")
+        self.assertLessEqual(
+            len(result.instances), 50,
+            "Expected list of process instances returned to be 50 or less"
+        )
+
+
+    def test_list_process_instances_empty_process_id(self):
+        with self.assertRaises(ValueError) as exception:
+            self.__list_process_instances(process_id="")
+
+        # The specific error message will depend on implementation
+        self.assertTrue(
+            "Process ID must be provided" in str(exception.exception),
+            "Expected error message for empty process id"
+        )

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

@@ -0,0 +1,138 @@
+from unittest import TestCase
+import unittest
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, AgenticProcessList
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListProcessesIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager()
+        self.filter_settings = FilterSettings(
+            start=0,
+            count=100,
+            allow_drafts=False
+        )
+
+    
+    def __list_processes(self, filter_settings: FilterSettings = None):
+        return self.ai_lab_manager.list_processes(
+            filter_settings if filter_settings is not None else self.filter_settings
+        )
+    
+    
+    def test_default_list_processes(self):
+        processes = self.__list_processes()
+        self.assertIsInstance(processes, AgenticProcessList, "Expected a list of processes")
+
+
+    def test_list_processes_with_id_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.id = "7e28e9ab-b9a2-417e-9e87-ed7f6ec9534b"
+        result = self.__list_processes(filter_settings=filter_settings)
+        print(result)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    process.id, filter_settings.id,
+                    f"Expected process ID to match filter value: {filter_settings.id}"
+                )
+
+
+    def test_list_processes_with_name_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.name = "ArithmeticProcess"
+        result = self.__list_processes(filter_settings=filter_settings)
+        print(result)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    "ArithmeticProcess",
+                    process.name,
+                    "Expected process name to contain filter value"
+                )
+
+
+    def test_list_processes_with_status_filter_active(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.status = "active"
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    process.status.lower(), "active",
+                    "Expected all processes to have active status"
+                )
+
+
+    def test_list_processes_with_status_filter_inactive(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.status = "inactive"
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        if result.processes:
+            for process in result.processes:
+                self.assertEqual(
+                    process.status.lower(), "inactive",
+                    "Expected all processes to have inactive status"
+                )
+
+
+    def test_list_processes_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+        result = self.__list_processes(filter_settings=filter_settings)
+        
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        self.assertLessEqual(
+            len(result.processes), 2,
+            "Expected list of processes returned to be 2 or less"
+        )
+
+
+    def test_list_processes_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 500
+        result = self.__list_processes(filter_settings=filter_settings)
+        
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        self.assertLessEqual(
+            len(result.processes), 500,
+            "Expected list of processes returned to be 500 or less"
+        )
+
+    @unittest.skip("Method is not returning drafts")
+    def test_list_processes_allow_drafts_true(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = True
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        # Note: This test verifies that draft processes are included when allow_drafts=True
+        has_draft = any(p.is_draft for p in result.processes)
+        self.assertTrue(has_draft, "Expected at least one draft process")
+
+
+    def test_list_processes_allow_drafts_false(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = False
+        result = self.__list_processes(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")
+        # Note: This test verifies that draft processes are excluded when allow_drafts=False
+        has_draft = any(p.is_draft == False for p in result.processes)
+        self.assertTrue(has_draft, "Expected at least one draft process")
+
+
+    def test_list_processes_none_filter_settings(self):
+        result = self.__list_processes(filter_settings=None)
+        self.assertIsInstance(result, AgenticProcessList, "Expected a list of processes")