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

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

@@ -0,0 +1,201 @@
+from unittest import TestCase
+import unittest
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import AgenticProcess, FilterSettings, KnowledgeBase, AgenticActivity, ArtifactSignal, UserSignal, Event, SequenceFlow
+from pygeai.core.common.exceptions import APIResponseError, APIError, MissingRequirementException
+import copy
+import uuid
+
+
+class TestAILabGetProcessIntegration(TestCase):   
+
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.process_id = "7e28e9ab-b9a2-417e-9e87-ed7f6ec9534b"
+        self.process_name = "Test Process For Sdk Project"
+        self.filter_settings = FilterSettings(
+            revision="0",
+            version="0"
+        )
+
+
+    def __get_process(self, process_id=None, process_name=None, filter_settings: FilterSettings = None):
+        """
+        Helper method to get a process.
+        """
+        return self.ai_lab_manager.get_process(
+            process_id=self.process_id if process_id is None else process_id,
+            process_name=self.process_name if process_name is None else process_name,
+            filter_settings=self.filter_settings if filter_settings is None else filter_settings
+        )
+
+    def test_get_process_by_id(self):
+        """
+        Test getting a process by ID.
+        """
+        process = self.__get_process(process_name="")
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertEqual(process.id, self.process_id)
+
+
+    def test_get_process_by_name(self):
+        """
+        Test getting a process by name instead of ID.
+        """
+        process = self.__get_process(process_id=None)
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertEqual(process.name, self.process_name)
+
+    
+    def test_get_process_no_id_or_name(self):
+        """
+        Test getting a process without providing ID or name should raise an error.
+        """
+        with self.assertRaises(MissingRequirementException) as context:
+            self.__get_process(process_id="", process_name="")
+        self.assertIn(
+            "Either process_id or process_name must be provided",
+            str(context.exception),
+            "Expected an error for no id or name provided"
+        )
+
+
+    def test_get_process_invalid_process_id(self):
+        """
+        Test getting a process with an invalid ID.
+        """
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(APIError) as context:
+            self.__get_process(process_id=invalid_id, process_name="")
+        self.assertIn(
+            f"Process not found [IdOrName= {invalid_id}]",
+            str(context.exception),
+            "Expected an error for invalid process id"
+        )
+
+
+    def test_get_process_invalid_process_name(self):
+        """
+        Test getting a process with an invalid name.
+        """
+        invalid_name = "NonExistentProcessName_12345"
+        with self.assertRaises(APIError) as context:
+            self.__get_process(process_id="", process_name=invalid_name)
+        self.assertIn(
+            f"Process not found [IdOrName= {invalid_name}]",
+            str(context.exception),
+            "Expected an error for invalid process name"
+        )
+
+    def test_get_process_no_revision(self):
+        """
+        Test getting a process without specifying revision (should return latest).
+        """
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = None
+        process = self.__get_process(filter_settings=filter_settings)
+
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertGreaterEqual(process.revision or 0, 0, "Expected process revision to be the latest")
+
+
+    def test_get_process_by_revision(self):
+        """
+        Test getting a process by specific revision.
+        """
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = 4
+        process = self.__get_process(filter_settings=filter_settings)
+
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertEqual(process.revision, filter_settings.revision, f"Expected process revision to be {filter_settings.revision}")
+
+    
+    def test_get_process_by_earlier_revision(self):
+        """
+        Test getting a process by an earlier revision that might not exist.
+        """
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = 3
+        process = self.__get_process(filter_settings=filter_settings)
+        
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertEqual(process.revision, filter_settings.revision, f"Expected process revision to be {filter_settings.revision}")
+
+
+    def test_get_process_no_version(self):
+        """
+        Test getting a process without specifying version (should return latest).
+        """
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = None
+        process = self.__get_process(filter_settings=filter_settings)
+
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertGreaterEqual(process.version_id or 0, 0, "Expected process version to be the latest")
+
+
+    def test_get_process_by_version(self):
+        """
+        Test getting a process by specific version.
+        """
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = "2"
+        process = self.__get_process(filter_settings=filter_settings)
+        
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertEqual(process.version_id, 2, "Expected process version to be 2")
+
+
+    def test_get_process_by_invalid_version(self):
+        """
+        Test getting a process by an invalid version.
+        """
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.version = "999"  # Non-existent version
+        
+        with self.assertRaises(APIError) as context:
+            self.__get_process(filter_settings=filter_settings)
+        
+        self.assertIn(
+            "Requested version not found [version=999]",
+            str(context.exception),
+            "Expected an error for version not found"
+        )
+
+
+    def test_get_process_allow_drafts_true(self):
+        """
+        Test getting a process with allow_drafts=True (should include drafts).
+        """
+
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = True
+        process = self.__get_process(filter_settings = filter_settings)
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        # Draft processes should be retrievable
+        self.assertTrue(
+            process.is_draft,
+            "Should be able to retrieve both draft and published processes"
+        )
+
+    
+    def test_get_process_allow_drafts_false(self):
+        """
+        Test getting a process with allow_drafts=False (should exclude drafts).
+        """
+        
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = False
+        process = self.__get_process(filter_settings = filter_settings)
+
+        self.assertIsInstance(process, AgenticProcess, "Expected an AgenticProcess")
+        self.assertFalse(
+            process.is_draft,
+            "Should be able to retrieve published revisions"
+        )
+            
+    

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

@@ -0,0 +1,289 @@
+from unittest import TestCase
+import uuid
+
+from pydantic import ValidationError
+from pygeai.core.common.exceptions import APIResponseError, APIError
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import (
+    AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, Task, 
+    UserSignal, Event, SequenceFlow, Variable
+)
+
+
+class TestAILabUpdateProcessIntegration(TestCase):  
+    def setUp(self):
+        """
+        Set up the test environment.
+        """
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.process_to_update = self.__load_process()
+        self.created_process: AgenticProcess = None
+        self.updated_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.
+        """
+        self.random_str = str(uuid.uuid4())
+        return AgenticProcess(
+            id="3c071d2f-a044-4513-b2c0-6d27d9420693",
+            key=f"sdk_project_updated_process_{self.random_str[:8]}",
+            name=f"Updated Agentic Process {self.random_str[:8]}",
+            description=f"Process updated for SDK testing purposes {self.random_str[:8]}",
+            kb=KnowledgeBase(name="basic-sample", artifact_type_name=["sample-artifact"]),
+            agentic_activities=[
+                AgenticActivity(key="activityOne", name="First Step Updated", task_name="basic-task", agent_name="GoogleSummarizer2", agent_revision_id=0)
+            ],
+            artifact_signals=[
+                ArtifactSignal(key="artifact.upload.1", name="artifact.upload.updated", handling_type="C", artifact_type_name=["sample-artifact"])
+            ],
+            user_signals=[
+                UserSignal(key="signal_done", name="process-completed-updated")
+            ],
+            start_event=Event(key="artifact.upload.1", name="artifact.upload.updated"),
+            end_event=Event(key="end", name="Done Updated"),
+            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")
+            ]
+        )
+    
+
+    def __update_process(self, process: AgenticProcess = None, automatic_publish: bool = False, upsert: bool = False):
+        """
+        Helper method to update a process.
+        """
+        return self.ai_lab_manager.update_process(
+            process=self.process_to_update if process is None else process,
+            automatic_publish=automatic_publish,
+            upsert=upsert
+        )
+
+
+    def test_update_process_all_fields_success(self):
+        """
+        Test updating a process with all available fields populated.
+        """
+        self.updated_process = self.__update_process()
+        
+        # Assertions
+        self.assertEqual(self.updated_process.name, self.process_to_update.name)
+        self.assertEqual(self.updated_process.description, self.process_to_update.description)
+        
+        # Assert knowledge base
+        self.assertIsNotNone(self.updated_process.kb)
+        self.assertEqual(self.updated_process.kb.name, self.process_to_update.kb.name)
+        
+        # Assert agentic activities
+        self.assertIsNotNone(self.updated_process.agentic_activities)
+        updated_activity = self.updated_process.agentic_activities[0]
+        original_activity = self.process_to_update.agentic_activities[0]
+        self.assertEqual(updated_activity.name, original_activity.name)
+
+        # Assert artifact signals
+        updated_signal = self.updated_process.artifact_signals[0]
+        original_signal = self.process_to_update.artifact_signals[0]
+        self.assertTrue(isinstance(updated_signal, ArtifactSignal))        
+        self.assertEqual(updated_signal.key.lower(), original_signal.key.lower())
+        self.assertEqual(updated_signal.name, original_signal.name)
+        self.assertEqual(updated_signal.handling_type, original_signal.handling_type)
+        
+        # Assert that the process is in draft state after update
+        self.assertTrue(self.updated_process.is_draft, "Expected process to be in draft state after update")
+
+
+    def test_update_process_minimum_fields_success(self):
+        """
+        Test updating a process with minimum required fields (only name).
+        """
+        # Update with minimal data
+        minimal_update = AgenticProcess(
+            id=self.process_to_update.id,
+            name=f"Minimal Updated Process {str(uuid.uuid4())[:8]}"
+        )
+        
+        self.updated_process = self.__update_process(process=minimal_update)
+        self.assertEqual(self.updated_process.name, minimal_update.name)
+
+
+    def test_update_process_invalid_name(self):
+        """
+        Test updating a process with invalid characters in name.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):                
+                # Test invalid characters
+                invalid_names = [
+                    f"{self.process_to_update.name}:invalid",
+                    f"{self.process_to_update.name}/invalid"
+                ]
+
+                for invalid_name in invalid_names:
+                    with self.assertRaises(APIError) as exception:
+                        self.process_to_update.name = invalid_name
+                        self.__update_process(automatic_publish=auto_publish)
+                    
+                    self.assertIn(
+                        f"Invalid character in name ({':' if ":" in invalid_name else "/"} is not allowed).",
+                        str(exception.exception),                    
+                        f"Expected an error about invalid character in process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                    )
+
+
+    def test_update_process_duplicated_name(self):
+        """
+        Test updating a process with a name that already exists.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.process_to_update.name = "Test Process For Sdk Project"
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "A process with this name already exists",
+                    str(exception.exception),                    
+                    f"Expected an error about duplicated process name with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+    
+
+    def test_update_process_no_name(self):
+        """
+        Test updating a process without providing a name.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.process_to_update.name = ""
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    "Process name cannot be empty",
+                    str(exception.exception),                    
+                    f"Expected an error when process name is empty with autopublish {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_process_invalid_id(self):
+        """
+        Test updating a process with an invalid ID.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+                self.process_to_update.id = invalid_id
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    f"Process-Definition not found [IdOrName= {invalid_id}]",
+                    str(exception.exception),                    
+                    f"Expected an error when process id is invalid and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_process_no_id_invalid_name(self):
+        """
+        Test updating a process without ID.
+        """
+        test_params = [True, False]
+        
+        for auto_publish in test_params:
+            with self.subTest(input=auto_publish):
+                self.process_to_update.id = ""
+                
+                with self.assertRaises(APIError) as exception:
+                    self.__update_process(automatic_publish=auto_publish)
+                
+                self.assertIn(
+                    f"Process-Definition not found [IdOrName= {self.process_to_update.name}]",
+                    str(exception.exception),                    
+                    f"Expected an error when process id is invalid and autopublish is {'enabled' if auto_publish else 'disabled'}"
+                )
+
+
+    def test_update_process_knowledge_base(self):
+        """
+        Test updating a process with different knowledge base configurations.
+        """
+        
+        # Update with different KB
+        self.process_to_update.kb = KnowledgeBase(name="updated-kb", artifact_type_name=["updated-artifact"])
+        
+        self.updated_process = self.__update_process()
+        self.assertEqual(self.updated_process.kb.name, "updated-kb")
+        self.assertEqual(self.updated_process.kb.artifact_type_name, ["updated-artifact"])
+
+
+    def test_update_process_automatic_publish(self):
+        """
+        Test updating a process with automatic publish enabled.
+        """        
+        # Create a task for publishing
+        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)
+        
+        # Update process with task reference
+        self.process_to_update.agentic_activities[0].task_name = unique_key
+        
+        self.updated_process = self.__update_process(automatic_publish=True)
+        self.assertFalse(self.updated_process.is_draft, "Expected process to be published after update with automatic_publish=True")    
+
+
+    def test_update_process_upsert_existing(self):
+        """
+        Test updating a process with upsert=True when process exists.
+        """
+        # Update existing process with upsert
+        self.updated_process = self.__update_process(upsert=True)
+        self.assertEqual(self.updated_process.name, self.process_to_update.name)
+        self.assertEqual(self.updated_process.id, self.process_to_update.id)
+
+
+    def test_update_process_upsert_new(self):
+        """
+        Test updating a process with upsert=True when process doesn't exist (should create new).
+        """
+        new_id = str(uuid.uuid4())
+        self.process_to_update.id = new_id
+        
+        self.created_process = self.__update_process(upsert=True)
+        self.assertEqual(self.created_process.name, self.process_to_update.name)
+        self.assertIsNotNone(self.created_process.id)
+
+
+    def test_update_process_by_name_instead_of_id(self):
+        """
+        Test updating a process by name instead of ID.
+        """
+        self.process = self.ai_lab_manager.get_process(self.process_to_update.id)
+        self.process_to_update.id = None
+        self.process_to_update.name = self.process.name
+        self.process_to_update.description = "Updated via name instead of ID"
+        
+        
+        self.updated_process = self.__update_process()
+        self.assertEqual(self.updated_process.description, "Updated via name instead of ID")

pygeai/tests/integration/lab/reasoning_strategies/test_get_reasoning_strategy.py

@@ -0,0 +1,70 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import ReasoningStrategy
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabGetReasoningStrategyIntegration(TestCase):   
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.strategy_id = "0a3b039e-25bd-4cf9-ad67-7af2b654874b"
+        self.strategy_name = "Chain of Thought"
+
+    def __get_reasoning_strategy(self, strategy_id = None, strategy_name = None):
+        return self.ai_lab_manager.get_reasoning_strategy(
+            reasoning_strategy_id= strategy_id if strategy_id is not None else self.strategy_id,
+            reasoning_strategy_name=strategy_name if strategy_name is not None else self.strategy_name
+        )
+
+    def test_get_reasoning_strategy_by_id(self):
+        strategy = self.__get_reasoning_strategy(strategy_name="")
+
+        self.assertIsInstance(strategy, ReasoningStrategy, "Expected a reasoning strategy")
+        self.assertEqual(strategy.id, self.strategy_id, "Expected reasoning strategy ID to match")
+
+
+    def test_get_reasoning_strategy_by_name(self):
+        strategy = self.__get_reasoning_strategy(strategy_id="")
+        
+        self.assertIsInstance(strategy, ReasoningStrategy, "Expected a reasoning strategy")
+        self.assertEqual(
+            strategy.name, 
+            self.strategy_name,
+            "Expected reasoning strategy name to match"
+        )
+
+
+    def test_get_reasoning_strategy_no_id_or_name(self):
+        with self.assertRaises(Exception) as context:
+            self.__get_reasoning_strategy(strategy_id="", strategy_name="")
+
+        self.assertIn(
+            "Either reasoning_strategy_id or reasoning_strategy_name must be provided.",
+            str(context.exception),
+            "Expected error message for missing id and name"
+        )
+
+
+    def test_get_reasoning_strategy_invalid_id(self):
+        invalid_id = "invalid-id-1234"
+        with self.assertRaises(APIError) as context:
+            self.__get_reasoning_strategy(strategy_id=invalid_id)
+        self.assertIn(
+            f"Reasoning-Strategy not found (idOrName={invalid_id}",
+            str(context.exception),
+            "Expected an error for invalid reasoning strategy id"
+        )
+
+
+    def test_get_reasoning_strategy_invalid_name(self):
+        invalid_name = "Nonexistent Strategy"
+        with self.assertRaises(APIError) as context:
+            self.__get_reasoning_strategy(strategy_id="", strategy_name=invalid_name)
+
+        self.assertIn(
+            f"Reasoning-Strategy not found (idOrName={invalid_name})",
+            str(context.exception),
+            "Expected an error for invalid reasoning strategy name"
+        )

pygeai/tests/integration/lab/reasoning_strategies/test_list_reasoning_strategies.py

@@ -0,0 +1,93 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, ReasoningStrategyList
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListReasoningStrategiesIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.filter_settings = FilterSettings(
+            name="",
+            start=0,
+            count=100,
+            allow_external=True,
+            access_scope="public"
+        )
+
+    
+    def __list_reasoning_strategies(self, filter_settings: FilterSettings = None):
+        filter_settings = filter_settings if filter_settings is not None else self.filter_settings
+        return self.ai_lab_manager.list_reasoning_strategies(filter_settings=filter_settings)
+    
+    
+    def test_public_list_reasoning_strategies(self):
+        result = self.__list_reasoning_strategies()
+
+        self.assertIsInstance(result, ReasoningStrategyList, "Expected a list of reasoning strategies")
+        for strategy in result.strategies:
+            self.assertTrue(
+                strategy.access_scope == "public",
+                "Expected all reasoning strategies to be public"
+            )
+
+
+    def test_private_list_reasoning_strategies(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "private"
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+
+        self.assertIsInstance(result, ReasoningStrategyList, "Expected a list of reasoning strategies")
+        for strategy in result.strategies:
+            self.assertTrue(
+                strategy.access_scope == "private",
+                "Expected all reasoning strategies to be private"
+            )
+
+
+    def test_list_reasoning_strategies_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertEqual(
+            len(result), 2,
+            "Expected list of reasoning strategies returned to be 2"
+        )
+
+
+    def test_list_reasoning_strategies_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 500
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertLessEqual(
+            len(result), 500,
+            "Expected list of reasoning strategies returned to be 500 or less"
+        )
+
+
+    def test_list_reasoning_strategies_name_filter(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.name = "Chain of Thought"
+        result = self.__list_reasoning_strategies(filter_settings=filter_settings)
+
+        for strategy in result.strategies:
+            self.assertIn(
+                "Chain of Thought",
+                strategy.name,
+                "Expected reasoning strategy name to contain filter value"
+            )
+
+   
+    def test_list_reasoning_strategies_invalid_scope(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "project"
+
+        with self.assertRaises(ValueError) as exception:
+            self.__list_reasoning_strategies(filter_settings=filter_settings)
+        self.assertIn(
+            "Access scope must be either 'public' or 'private'.",
+            str(exception.exception),
+            "The expected error about invalid scope was not returned"
+        )