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

pygeai/tests/integration/lab/tools/test_create_tool.py

@@ -1,10 +1,8 @@
 from unittest import TestCase
-import unittest
 import uuid
 from pygeai.lab.managers import AILabManager
-from pygeai.lab.models import Agent, AgentData, Prompt, LlmConfig, Model, Tool, ToolParameter,Sampling, PromptExample, PromptOutput
-from pydantic import ValidationError
-from pygeai.core.common.exceptions import APIError, InvalidAPIResponseException 
+from pygeai.lab.models import Tool, ToolParameter
+from pygeai.core.common.exceptions import APIResponseError
 
 
 class TestAILabCreateToolIntegration(TestCase):    
@@ -14,7 +12,7 @@ class TestAILabCreateToolIntegration(TestCase):
         """
         self.ai_lab_manager = AILabManager(alias="beta")
         self.new_tool = self.__load_tool()
-        self.created_tool: Agent = None
+        self.created_tool: Tool = None
 
 
     def tearDown(self):
@@ -28,7 +26,6 @@ class TestAILabCreateToolIntegration(TestCase):
 
     
     def __load_tool(self):
-        #random_str = str(uuid.uuid4())
         return Tool(
             name=str(uuid.uuid4()),
             description="Tool created for sdk testing purposes",
@@ -96,15 +93,12 @@ class TestAILabCreateToolIntegration(TestCase):
 
         for auto_publish in test_params:
             
-            with self.subTest(input=auto_publish):     
-                with self.assertRaises(ValidationError) as context:
-                    self.new_tool = Tool(
+            with self.subTest(input=auto_publish): 
+                self.new_tool = Tool(
                         name=str(uuid.uuid4())
                     )
-                    self.__create_tool(automatic_publish=auto_publish)
-
-                self.assertIn("description", str(context.exception))
-                self.assertIn("Field required", str(context.exception))
+                created_tool = self.__create_tool(automatic_publish=auto_publish)
+                self.assertTrue(isinstance(created_tool, Tool), "Expected a created tool")    
 
 
     def test_create_tool_no_name(self):
@@ -113,7 +107,7 @@ class TestAILabCreateToolIntegration(TestCase):
         for auto_publish in test_params:
             with self.subTest(input=auto_publish):
                 self.new_tool.name = ""
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
 
                 self.assertIn(
@@ -130,7 +124,7 @@ class TestAILabCreateToolIntegration(TestCase):
 
             with self.subTest(input=auto_publish):
                 self.new_tool.name = "sdk_project_gemini_tool"
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Tool already exists [name=sdk_project_gemini_tool]..",
@@ -147,7 +141,7 @@ class TestAILabCreateToolIntegration(TestCase):
                 new_tool = self.__load_tool()
                 new_tool2 = self.__load_tool()
 
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     new_tool.name = f"{new_tool.name}:invalid"
                     self.__create_tool(tool=new_tool, automatic_publish=auto_publish)
                 self.assertIn(
@@ -156,7 +150,7 @@ class TestAILabCreateToolIntegration(TestCase):
                     f"Expected an error about invalid character (:) in tool name with autopublish {'enabled' if auto_publish else 'disabled'}"
                 )
 
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     new_tool2.name = f"{new_tool2.name}/invalid"
                     self.__create_tool(tool=new_tool2, automatic_publish=auto_publish)
                 self.assertIn(
@@ -192,7 +186,7 @@ class TestAILabCreateToolIntegration(TestCase):
             with self.subTest(input=auto_publish):
                 self.new_tool.access_scope = "public"
                 self.new_tool.public_name = None
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
                 self.assertIn(
                     "Tool publicName is required for tools with accessScope=public.",
@@ -208,7 +202,7 @@ class TestAILabCreateToolIntegration(TestCase):
             with self.subTest(input=auto_publish): 
                 self.new_tool.access_scope = "public"
                 self.new_tool.public_name = "com.sdk.testing#"  # Add invalid character to public name
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(automatic_publish=auto_publish)
 
                 self.assertIn(
@@ -234,7 +228,7 @@ class TestAILabCreateToolIntegration(TestCase):
                 duplicated_pn_tool.access_scope = "public"
                 duplicated_pn_tool.public_name = self.created_tool.public_name
                 
-                with self.assertRaises(APIError) as exception:
+                with self.assertRaises(APIResponseError) as exception:
                     self.__create_tool(tool=duplicated_pn_tool, automatic_publish=auto_publish)
                 self.assertIn(
                     f"Tool already exists [publicName={self.created_tool.public_name}].",

pygeai/tests/integration/lab/tools/test_delete_tool.py

@@ -1,8 +1,8 @@
 from unittest import TestCase
 import uuid
 from pygeai.lab.managers import AILabManager
-from pygeai.lab.models import Tool, AgentData, Prompt, LlmConfig, Model
-from pygeai.core.common.exceptions import MissingRequirementException, InvalidAPIResponseException
+from pygeai.lab.models import Tool
+from pygeai.core.common.exceptions import APIResponseError, MissingRequirementException, InvalidAPIResponseException
 
 ai_lab_manager: AILabManager
 
@@ -66,7 +66,7 @@ class TestAILabDeleteToolIntegration(TestCase):
     def test_delete_tool_invalid_id_valid_name(self):
         invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
         created_tool = self.__create_tool() 
-        with self.assertRaises(InvalidAPIResponseException) as exception:
+        with self.assertRaises(APIResponseError) as exception:
             self.__delete_tool(tool_name=created_tool.name, tool_id=invalid_id)
 
         self.assertIn(

pygeai/tests/integration/lab/tools/test_get_parameter.py

@@ -0,0 +1,98 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import FilterSettings, ToolParameter
+from pygeai.core.common.exceptions import APIResponseError, MissingRequirementException
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabGetParameterIntegration(TestCase):   
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.tool_id = "42610b61-cb47-49bf-9475-36ee652f31f3"
+        self.filter_settings = FilterSettings(
+            revision="0",
+            version="0",
+            allow_drafts=True
+        )
+
+
+    def __get_parameter(self, tool_id: str = None, tool_public_name: str = None, filter_settings: FilterSettings = None):
+        return self.ai_lab_manager.get_parameter(
+            tool_id=self.tool_id if tool_id is None else tool_id,
+            tool_public_name=tool_public_name,
+            filter_settings=self.filter_settings if filter_settings is None else filter_settings
+        )   
+    
+
+    def test_get_parameter(self):
+        tool_parameters = self.__get_parameter()
+       
+        for param in tool_parameters:
+            self.assertIsInstance(param, ToolParameter, "Expected a tool parameter")
+ 
+
+    def test_get_parameter_invalid_tool_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+
+        with self.assertRaises(APIResponseError) as exception:
+            self.__get_parameter(tool_id=invalid_id)
+        self.assertIn(
+            f"Tool not found [IdOrName= {invalid_id}]",
+            str(exception.exception),
+            "Expected error when trying to send an invalid tool id"
+        )
+
+  
+    def test_get_parameter_no_tool_id(self):
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__get_parameter(tool_id="")
+        self.assertIn(
+            "Either tool_id or tool_public_name must be provided.",
+            str(exception.exception),
+            "Expected error when trying to send a request without tool_id"
+        )
+
+
+    def test_get_parameter_by_tool_public_name(self):
+        tool_parameters = self.__get_parameter(tool_public_name="test.sdk.beta.tool")
+
+        for param in tool_parameters:
+            self.assertIsInstance(param, ToolParameter, "Expected a tool parameter")
+
+
+    def test_get_parameter_by_invalid_public_name(self):
+        invalid_public_name = "test.sdk.beta.tool.invalid"
+
+        with self.assertRaises(APIResponseError) as exception:
+            self.__get_parameter(tool_public_name=invalid_public_name)
+        self.assertIn(
+             f"Tool not found [IdOrName= {invalid_public_name}]",
+            str(exception.exception),
+            "Expected error when trying to send a request without tool_id"
+        )
+
+
+    def test_get_parameter_by_past_revision(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = "3"
+
+        with self.assertRaises(APIResponseError) as exception:
+            self.__get_parameter(filter_settings=filter_settings)
+        self.assertIn(
+            "Requested revision not found [revision=3].",
+            str(exception.exception),
+            "Expected error when trying to send a request without tool_id"
+        )
+
+    
+    def test_get_parameter_by_draft_revision(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.revision = "10"
+        tool_parameters = self.__get_parameter(filter_settings=filter_settings)
+
+        for param in tool_parameters:
+            self.assertIsInstance(param, ToolParameter, "Expected a tool parameter")
+
+    

pygeai/tests/integration/lab/tools/test_get_tool.py

@@ -2,7 +2,7 @@ from unittest import TestCase
 import unittest
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Tool, FilterSettings
-from pygeai.core.common.exceptions import APIError
+from pygeai.core.common.exceptions import APIResponseError
 import copy
 
 ai_lab_manager: AILabManager
@@ -36,7 +36,7 @@ class TestAILabGetToolIntegration(TestCase):
     
     def test_get_tool_invalid_tool_id(self):
         invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
-        with self.assertRaises(APIError) as context:
+        with self.assertRaises(APIResponseError) as context:
             self.__get_tool(tool_id=invalid_id)
         self.assertIn(
             f"Tool not found [IdOrName= {invalid_id}].",
@@ -65,7 +65,7 @@ class TestAILabGetToolIntegration(TestCase):
     def test_get_tool_by_earlier_revision(self):
         filter_settings = copy.deepcopy(self.filter_settings)
         filter_settings.revision = "2"
-        with self.assertRaises(APIError) as context:
+        with self.assertRaises(APIResponseError) as context:
             self.__get_tool(filter_settings=filter_settings)
         self.assertIn(
             f"Requested revision not found [revision={filter_settings.revision}].",

pygeai/tests/integration/lab/tools/test_list_tools.py

@@ -0,0 +1,106 @@
+from unittest import TestCase
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import ToolList, FilterSettings
+import copy
+
+ai_lab_manager: AILabManager
+
+class TestAILabListToolsIntegration(TestCase):    
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.filter_settings = FilterSettings(
+            allow_external=False,
+            allow_drafts=True,
+            access_scope="private"
+        )
+
+
+    def __list_tools(self, filter_settings: FilterSettings = None):
+        filter_settings = filter_settings if filter_settings != None else self.filter_settings
+        return self.ai_lab_manager.list_tools(filter_settings=filter_settings)
+    
+    
+    def test_private_list_tools(self):
+        result = self.__list_tools()
+        self.assertIsInstance(result, ToolList , "Expected a list of tools") 
+
+        for tool in result.tools:
+            self.assertTrue(tool.access_scope == "private", "Expected all tools to be private")
+
+
+    def test_public_list_tools(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.access_scope = "public"
+
+        result = self.__list_tools(filter_settings=filter_settings)
+        self.assertIsInstance(result, ToolList , "Expected a list of tools") 
+
+        for tool in result.tools:
+            self.assertTrue(tool.access_scope == "public", "Expected all tools to be public")
+
+     
+    def test_list_tools_small_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 2
+
+        result = self.__list_tools(filter_settings=filter_settings)
+        self.assertIsInstance(result, ToolList , "Expected a list of tools") 
+        
+        self.assertEqual(len(result), 2, "Expected list of tools returned to be 2")  
+
+
+    def test_list_tools_big_count(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.count = 500
+
+        result = self.__list_tools(filter_settings=filter_settings)
+        self.assertIsInstance(result, ToolList , "Expected a list of tools") 
+        
+        self.assertLessEqual(len(result), 500, "Expected list of tools returned to be 500 or less")
+
+
+    def test_list_tools_allowing_draft(self):
+        result = self.__list_tools()
+        validated = any(tool.is_draft == True for tool in result.tools)        
+        self.assertTrue(
+            validated,
+            "Expected at least one tool to be a draft"
+        )
+
+    
+    def test_list_tools_no_draft(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_drafts = False
+        result = self.__list_tools(filter_settings=filter_settings)
+        
+        validated = any(tool.is_draft == True for tool in result.tools)        
+        self.assertFalse(
+            validated,
+            "Expected no draft tools in the list"
+        )
+
+
+    def test_list_tools_invalid_scope(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.scope = "project"
+        
+        with self.assertRaises(ValueError) as exception:
+           self.__list_tools(filter_settings=filter_settings)
+
+        self.assertIn(
+            "Scope must be one of builtin, external, api, proxied.",
+            str(exception.exception),                    
+            f"The expected error about invalid scope was not returned"
+        )
+
+
+    def test_list_tools_allowing_external(self):
+        filter_settings = copy.deepcopy(self.filter_settings)
+        filter_settings.allow_external = False
+        
+        result = self.__list_tools(filter_settings=filter_settings)
+        self.assertIsInstance(result, ToolList , "Expected a list of tools") 
+        
+
+

pygeai/tests/integration/lab/tools/test_publish_tool_revision.py

@@ -0,0 +1,119 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import Tool
+from pygeai.core.common.exceptions import APIError
+
+ai_lab_manager: AILabManager
+
+class TestAILabPublishToolRevisionIntegration(TestCase):   
+
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.tool_id = "c77e1f2e-0322-4dd0-b6ec-aff217f1cb32"
+
+
+    def __publish_tool_revision(self, revision: str, tool_id=None):
+        return self.ai_lab_manager.publish_tool_revision(
+            tool_id=self.tool_id if tool_id is None else tool_id,
+            revision=revision
+        )
+
+    def __load_tool(self):
+        self.random_str = str(uuid.uuid4())
+        return Tool(
+            id="c77e1f2e-0322-4dd0-b6ec-aff217f1cb32",
+            name=f"sdk_project_updated_tool_{self.random_str}",
+            description=f"Tool updated for sdk testing purposes {self.random_str}",
+            scope="builtin",
+            openApi="https://raw.usercontent.com//openapi.json",
+            openApiJson={"openapi": "3.0.0","info": {"title": f"Simple API overview {self.random_str}","version": "3.0.0"}},
+            accessScope="private",
+            reportEvents="None",
+            parameters=[{
+                "key": "param", 
+                "description": f"param description {self.random_str}",
+                "type":"app", 
+                "value": f"value {self.random_str}",
+                "data_type": "String",
+                "isRequired": False
+            }]
+        )
+    
+
+    def __update_tool(self, tool: Tool = None, automatic_publish: bool = False, upsert: bool = False):
+        """
+        Helper method to update a tool.
+        """
+        tool = self.__load_tool()
+        return self.ai_lab_manager.update_tool(
+            tool = tool,
+            automatic_publish=False, 
+            upsert=False
+        )
+    
+
+    def test_publish_tool_revision(self):
+        updated_tool = self.__update_tool()
+        new_revision = updated_tool.revision
+
+        published_tool = self.__publish_tool_revision(revision=str(new_revision))
+
+        self.assertFalse(published_tool.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_tool.revision, new_revision, "Expected last revision to be published") 
+ 
+
+    def test_publish_tool_earlier_revision_with_newer_revision_published(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_tool_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_tool_earlier_revision(self):
+        earlier_revision = (self.__update_tool()).revision
+        #update the tool to create a newer revision
+        self.__update_tool()
+
+        published_tool = self.__publish_tool_revision(revision=earlier_revision)
+
+        self.assertFalse(published_tool.is_draft, "Expected draft to be false after publishing the revision") 
+        self.assertEqual(published_tool.revision, earlier_revision, "Expected last revision to be published") 
+
+
+    def test_publish_tool_invalid_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_tool_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_tool_string_revision(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_tool_revision(revision="revision")
+        self.assertIn("Bad Request", str(exception.exception))
+        self.assertIn("400", str(exception.exception))
+
+
+    def test_publish_tool_invalid_tool_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+        with self.assertRaises(APIError) as exception:
+            self.__publish_tool_revision(revision="103", tool_id=invalid_id)
+        self.assertIn(
+            f"Tool not found [IdOrName= {invalid_id}].",
+            str(exception.exception),
+            "Expected error when sending and invalid agent id"
+        )
+
+    
+    def test_publish_tool_no_tool_id(self):
+        with self.assertRaises(APIError) as exception:
+            self.__publish_tool_revision(revision="103", tool_id="")
+        self.assertIn("Not Found", str(exception.exception))
+        self.assertIn("404", str(exception.exception))

pygeai/tests/integration/lab/tools/test_set_parameter.py

@@ -0,0 +1,114 @@
+from unittest import TestCase
+import uuid
+from pygeai.lab.managers import AILabManager
+from pygeai.lab.models import ToolParameter
+from pygeai.core.common.exceptions import MissingRequirementException, InvalidAPIResponseException
+
+ai_lab_manager: AILabManager
+
+class TestAILabSetParameterIntegration(TestCase):
+    def setUp(self):
+        self.ai_lab_manager = AILabManager(alias="beta")
+        self.tool_id = "42610b61-cb47-49bf-9475-36ee652f31f3"
+        self.tool_parameters = self.__load_parameters()
+
+
+    def __set_parameter(self, tool_id: str = None, tool_public_name: str = None, parameters: list = None):        
+        return self.ai_lab_manager.set_parameter(
+            tool_id = self.tool_id if tool_id is None else tool_id,
+            tool_public_name = tool_public_name,
+            parameters = self.tool_parameters if parameters is None else parameters,
+        )
+    
+    
+    def __load_parameters(self):
+        random_str = str(uuid.uuid4())
+        return [
+            ToolParameter(
+                key="param3",
+                data_type="String",
+                description=f"{random_str}_config",
+                is_required=True,
+                type="config",
+                value=random_str
+            )
+        ]
+        
+
+    def test_set_parameter(self):  
+        result = self.__set_parameter()
+        self.assertEqual(
+            result.content, 
+            "Parameter set successfully",
+            "Expected successful parameter update"
+        )
+
+
+    def test_set_parameter_invalid_tool_id(self):
+        invalid_id = "0026e53d-ea78-4cac-af9f-12650invalid"
+
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.__set_parameter(tool_id=invalid_id)
+
+        self.assertIn(
+            f"Unable to set parameter for tool {invalid_id}",
+            str(context.exception),
+            "Expected error for invalid tool ID"
+        )
+
+    
+    def test_set_parameter_no_tool_id(self):
+        with self.assertRaises(MissingRequirementException) as context:
+            self.__set_parameter(tool_id="")
+
+        self.assertIn(
+            "Either tool_id or tool_public_name must be provided.",
+            str(context.exception),
+            "Expected error for invalid tool ID"
+        )
+
+
+    def test_set_parameter_by_tool_public_name(self):
+        self.tool_parameters[0].key = "Param1"
+
+        result = self.__set_parameter(tool_id = "", tool_public_name="test.sdk.beta.tool")
+        self.assertEqual(
+            result.content, 
+            "Parameter set successfully",
+            "Expected successful parameter update"
+        )
+
+
+    def test_set_parameter_by_invalid_public_name(self):
+        invalid_public_name = "test.sdk.beta.tool.invalid"
+
+        with self.assertRaises(InvalidAPIResponseException) as exception:
+            self.__set_parameter(tool_id = "", tool_public_name=invalid_public_name)
+        self.assertIn(
+            f"Unable to set parameter for tool {invalid_public_name}",
+            str(exception.exception),
+            "Expected error when trying to send a request without tool_id"
+        )
+
+
+    def test_set_parameter_no_parameters(self):
+        self.tool_parameters = []
+
+        with self.assertRaises(MissingRequirementException) as exception:
+            self.__set_parameter()
+        self.assertIn(
+            "Parameters list must be provided and non-empty.",
+            str(exception.exception),
+            "Expected error when trying to send a request without parameters"
+        )
+
+
+    def test_set_parameter_not_added_parameters(self):
+        #param3 set on self.tool_parameters, does not exist in the public tool
+        with self.assertRaises(InvalidAPIResponseException) as exception:
+            self.__set_parameter(tool_id = "", tool_public_name = "test.sdk.beta.tool")
+        self.assertIn(
+            "Parameter param3 not found in this tool",
+            str(exception.exception),
+            "Expected error when trying to send a request without parameters"
+        )