pygeai 0.6.0b13__py3-none-any.whl → 0.6.1__py3-none-any.whl

pygeai/tests/core/services/test_rest.py

@@ -1,7 +1,7 @@
 import unittest
 from unittest.mock import patch, Mock
 
-from pygeai.core.services.rest import ApiService
+from pygeai.core.services.rest import GEAIApiService
 from pygeai.core.common.exceptions import InvalidResponseException
 
 
@@ -11,10 +11,10 @@ class TestApiService(unittest.TestCase):
     """
     def setUp(self):
         self.base_url = "https://api.example.com"
-        self.api_service = ApiService(self.base_url, username="user", password="pass", token="test_token")
+        self.api_service = GEAIApiService(self.base_url, username="user", password="pass", token="test_token")
 
     def test_init_with_credentials(self):
-        service = ApiService(self.base_url, username="user", password="pass", token="token")
+        service = GEAIApiService(self.base_url, username="user", password="pass", token="token")
 
         self.assertEqual(service.base_url, self.base_url)
         self.assertEqual(service.username, "user")
@@ -22,7 +22,7 @@ class TestApiService(unittest.TestCase):
         self.assertEqual(service.token, "token")
 
     def test_init_without_credentials(self):
-        service = ApiService(self.base_url)
+        service = GEAIApiService(self.base_url)
 
         self.assertEqual(service.base_url, self.base_url)
         self.assertIsNone(service.username)
@@ -46,7 +46,7 @@ class TestApiService(unittest.TestCase):
 
     @patch('requests.Session.get')
     def test_get_request_with_token(self, mock_get):
-        api_service = ApiService(self.base_url, token="test_token")
+        api_service = GEAIApiService(self.base_url, token="test_token")
         mock_response = Mock()
         mock_response.url = f"{self.base_url}/test_endpoint"
         mock_get.return_value = mock_response
@@ -71,7 +71,7 @@ class TestApiService(unittest.TestCase):
         mock_get.assert_called_once_with(
             url=f"{self.base_url}/test_endpoint",
             params=None,
-            headers=None
+            headers={}
         )
         self.assertEqual(response, mock_response)
 
@@ -135,7 +135,7 @@ class TestApiService(unittest.TestCase):
         mock_post.assert_called_once_with(
             url=f"{self.base_url}/test_endpoint",
             json={"key": "value"},
-            headers=None,
+            headers={},
             stream=True
         )
         self.assertEqual(result, ["line1", "line2"])
@@ -160,7 +160,7 @@ class TestApiService(unittest.TestCase):
 
         mock_post.assert_called_once_with(
             url=f"{self.base_url}/test_endpoint",
-            headers=None,
+            headers={},
             data=mock_file
         )
         self.assertEqual(response, mock_response)
@@ -186,7 +186,7 @@ class TestApiService(unittest.TestCase):
 
         mock_post.assert_called_once_with(
             url=f"{self.base_url}/test_endpoint",
-            headers=None,
+            headers={},
             data={"key": "value"},
             files=mock_files
         )
@@ -256,7 +256,7 @@ class TestApiService(unittest.TestCase):
         self.assertEqual(result, f"{self.base_url}/test_endpoint")
 
     def test_add_endpoint_to_url_without_protocol(self):
-        api_service = ApiService("api.example.com")
+        api_service = GEAIApiService("api.example.com")
         result = api_service._add_endpoint_to_url("test_endpoint")
 
         self.assertEqual(result, "https://api.example.com/test_endpoint")

pygeai/tests/core/utils/test_console.py

@@ -1,4 +1,3 @@
-import unittest
 from unittest import TestCase
 from unittest.mock import MagicMock
 from pygeai.core.utils.console import Console, StreamWriter

pygeai/tests/dbg/test_debugger.py

@@ -1,7 +1,10 @@
 from unittest import TestCase
-from unittest.mock import patch, MagicMock, call
+from unittest.mock import patch, MagicMock
 from types import FrameType
-from pygeai.dbg.debugger import Debugger, Breakpoint
+import tempfile
+import os
+import shutil
+from pygeai.dbg.debugger import Debugger, Breakpoint, debug_file, debug_module
 
 
 class TestBreakpoint(TestCase):
@@ -63,13 +66,14 @@ class TestDebugger(TestCase):
         self.mock_console = self.console_patch.start()
         self.mock_console.write_stdout = MagicMock()
         
-        self.readline_patch = patch('pygeai.dbg.debugger.readline')
-        self.mock_readline = self.readline_patch.start()
+        self.util_patch = patch('pygeai.dbg.debugger.util.find_spec')
+        self.mock_find_spec = self.util_patch.start()
+        self.mock_find_spec.return_value = MagicMock()
 
     def tearDown(self):
         self.logging_patch.stop()
         self.console_patch.stop()
-        self.readline_patch.stop()
+        self.util_patch.stop()
 
     def test_debugger_init_default(self):
         debugger = Debugger()
@@ -401,8 +405,9 @@ class TestDebuggerCommands(TestCase):
         self.console_patch = patch('pygeai.dbg.debugger.Console')
         self.mock_console = self.console_patch.start()
         
-        self.readline_patch = patch('pygeai.dbg.debugger.readline')
-        self.mock_readline = self.readline_patch.start()
+        self.util_patch = patch('pygeai.dbg.debugger.util.find_spec')
+        self.mock_find_spec = self.util_patch.start()
+        self.mock_find_spec.return_value = MagicMock()
         
         self.pprint_patch = patch('pygeai.dbg.debugger.pprint')
         self.mock_pprint = self.pprint_patch.start()
@@ -410,7 +415,7 @@ class TestDebuggerCommands(TestCase):
     def tearDown(self):
         self.logging_patch.stop()
         self.console_patch.stop()
-        self.readline_patch.stop()
+        self.util_patch.stop()
         self.pprint_patch.stop()
 
     def test_handle_breakpoint_continue(self):
@@ -504,3 +509,85 @@ class TestDebuggerCommands(TestCase):
             with patch.object(debugger, '_get_source_lines', return_value=[(10, "test")]):
                 with self.assertRaises(SystemExit):
                     debugger.handle_breakpoint(mock_frame)
+
+
+class TestDebugFile(TestCase):
+    """Test debug_file helper function."""
+    
+    def setUp(self):
+        self.test_dir = tempfile.mkdtemp()
+        self.test_file = os.path.join(self.test_dir, "test_script.py")
+        with open(self.test_file, "w") as f:
+            f.write("""
+def main():
+    x = 10
+    y = 20
+    return x + y
+
+if __name__ == "__main__":
+    result = main()
+    print(result)
+""")
+    
+    def tearDown(self):
+        shutil.rmtree(self.test_dir)
+    
+    @patch("pygeai.dbg.debugger.logging")
+    @patch("pygeai.dbg.debugger.Console")
+    @patch("pygeai.dbg.debugger.util.find_spec")
+    def test_debug_file_creates_debugger(self, mock_find_spec, mock_console, mock_logging):
+        dbg = debug_file(self.test_file)
+        self.assertIsInstance(dbg, Debugger)
+        self.assertEqual(dbg.module_filter, "__main__")
+    
+    def test_debug_file_not_found(self):
+        with self.assertRaises(FileNotFoundError):
+            debug_file("/nonexistent/file.py")
+    
+    @patch("pygeai.dbg.debugger.logging")
+    @patch("pygeai.dbg.debugger.Console")
+    @patch("pygeai.dbg.debugger.util.find_spec")
+    def test_debug_file_with_args(self, mock_find_spec, mock_console, mock_logging):
+        dbg = debug_file(self.test_file, args=["arg1", "arg2"])
+        self.assertIsInstance(dbg, Debugger)
+    
+    @patch("pygeai.dbg.debugger.logging")
+    @patch("pygeai.dbg.debugger.Console")
+    @patch("pygeai.dbg.debugger.util.find_spec")
+    def test_debug_file_with_breakpoints(self, mock_find_spec, mock_console, mock_logging):
+        dbg = debug_file(self.test_file, breakpoint_specs=[(None, "main")])
+        self.assertEqual(len(dbg.breakpoints), 1)
+        self.assertIn((None, "main"), dbg.breakpoints)
+    
+    @patch("pygeai.dbg.debugger.logging")
+    @patch("pygeai.dbg.debugger.Console")
+    @patch("pygeai.dbg.debugger.util.find_spec")
+    def test_debug_file_with_pygeai_import(self, mock_find_spec, mock_console, mock_logging):
+        pygeai_file = os.path.join(self.test_dir, "test_pygeai.py")
+        with open(pygeai_file, "w") as f:
+            f.write("from pygeai.chat import ChatClient\n")
+        
+        dbg = debug_file(pygeai_file)
+        self.assertEqual(dbg.module_filter, "")
+
+
+class TestDebugModule(TestCase):
+    """Test debug_module helper function."""
+    
+    @patch("pygeai.dbg.debugger.logging")
+    @patch("pygeai.dbg.debugger.Console")
+    @patch("pygeai.dbg.debugger.util.find_spec")
+    def test_debug_module_creates_debugger(self, mock_find_spec, mock_console, mock_logging):
+        dbg = debug_module("os.path", "exists")
+        self.assertIsInstance(dbg, Debugger)
+        self.assertEqual(len(dbg.breakpoints), 1)
+        self.assertEqual(dbg.module_filter, "os")
+    
+    def test_debug_module_invalid_module(self):
+        with self.assertRaises(ImportError):
+            debug_module("nonexistent.module", "main")
+    
+    def test_debug_module_invalid_function(self):
+        with self.assertRaises(ImportError):
+            debug_module("os", "nonexistent_func")
+

pygeai/tests/evaluation/dataset/test_clients.py

@@ -1,8 +1,5 @@
 import unittest
-from unittest.mock import patch, MagicMock, mock_open
-import json
-from pathlib import Path
-from pygeai.core.base.session import Session
+from unittest.mock import patch, MagicMock
 
 from pygeai.evaluation.dataset.clients import EvaluationDatasetClient
 
@@ -18,14 +15,14 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         self.mock_response.json.return_value = {"id": "dataset-123", "status": "success"}
         self.mock_response.status_code = 200
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_datasets(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_datasets()
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "dataset-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_dataset_minimal(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.create_dataset(
@@ -40,7 +37,7 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['dataSetType'], "T")
         self.assertTrue(call_args[1]['data']['dataSetActive'])
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_dataset_with_rows(self, mock_post):
         mock_post.return_value = self.mock_response
         rows = [{"dataSetRowInput": "input1", "dataSetRowExpectedAnswer": "answer1"}]
@@ -58,7 +55,7 @@ class TestEvaluationDatasetClient(unittest.TestCase):
 
     @patch('pathlib.Path.is_file')
     @patch('pathlib.Path.open')
-    @patch('pygeai.core.services.rest.ApiService.post_file_binary')
+    @patch('pygeai.core.services.rest.GEAIApiService.post_file_binary')
     def test_create_dataset_from_file_success(self, mock_post, mock_open_file, mock_is_file):
         mock_is_file.return_value = True
         mock_file = MagicMock()
@@ -79,14 +76,14 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         with self.assertRaises(FileNotFoundError):
             self.client.create_dataset_from_file("/path/to/nonexistent.json")
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_dataset(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_dataset("dataset-123")
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "dataset-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_dataset(self, mock_put):
         mock_put.return_value = self.mock_response
         rows = [{"dataSetRowInput": "updated"}]
@@ -103,14 +100,14 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['dataSetName'], "Updated Dataset")
         self.assertEqual(call_args[1]['data']['rows'], rows)
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_dataset(self, mock_delete):
         mock_delete.return_value = self.mock_response
         result = self.client.delete_dataset("dataset-123")
         mock_delete.assert_called_once()
         self.assertEqual(result, {"id": "dataset-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_dataset_row(self, mock_post):
         mock_post.return_value = self.mock_response
         row = {
@@ -123,34 +120,34 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         call_args = mock_post.call_args
         self.assertEqual(call_args[1]['data'], row)
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_dataset_rows(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_dataset_rows("dataset-123")
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "dataset-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_dataset_row(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_dataset_row("dataset-123", "row-456")
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "dataset-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_dataset_row(self, mock_put):
         mock_put.return_value = self.mock_response
         row = {"dataSetRowInput": "updated input"}
         result = self.client.update_dataset_row("dataset-123", "row-456", row)
         mock_put.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_dataset_row(self, mock_delete):
         mock_delete.return_value = self.mock_response
         result = self.client.delete_dataset_row("dataset-123", "row-456")
         mock_delete.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_dataset_row_expected_source(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.create_expected_source(
@@ -162,19 +159,19 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         )
         mock_post.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_dataset_row_expected_sources(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_expected_sources("dataset-123", "row-456")
         mock_get.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_expected_source(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_expected_source("dataset-123", "row-456", "source-789")
         mock_get.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_expected_source(self, mock_put):
         mock_put.return_value = self.mock_response
         result = self.client.update_expected_source(
@@ -187,13 +184,13 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         )
         mock_put.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_expected_source(self, mock_delete):
         mock_delete.return_value = self.mock_response
         result = self.client.delete_expected_source("dataset-123", "row-456", "source-789")
         mock_delete.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_dataset_row_filter_variable(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.create_filter_variable(
@@ -206,19 +203,19 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         )
         mock_post.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_dataset_row_filter_variables(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_filter_variables("dataset-123", "row-456")
         mock_get.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_filter_variable(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_filter_variable("dataset-123", "row-456", "var-789")
         mock_get.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_filter_variable(self, mock_put):
         mock_put.return_value = self.mock_response
         result = self.client.update_filter_variable(
@@ -232,7 +229,7 @@ class TestEvaluationDatasetClient(unittest.TestCase):
         )
         mock_put.assert_called_once()
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_filter_variable(self, mock_delete):
         mock_delete.return_value = self.mock_response
         result = self.client.delete_filter_variable("dataset-123", "row-456", "var-789")
@@ -240,7 +237,7 @@ class TestEvaluationDatasetClient(unittest.TestCase):
 
     @patch('pathlib.Path.is_file')
     @patch('pathlib.Path.open')
-    @patch('pygeai.core.services.rest.ApiService.post_file_binary')
+    @patch('pygeai.core.services.rest.GEAIApiService.post_file_binary')
     def test_upload_dataset_rows_file_success(self, mock_post, mock_open_file, mock_is_file):
         mock_is_file.return_value = True
         mock_file = MagicMock()

pygeai/tests/evaluation/plan/test_clients.py

@@ -1,8 +1,6 @@
 import unittest
 from unittest.mock import patch, MagicMock
-import json
 
-from pygeai.core.base.session import Session
 from pygeai.evaluation.plan.clients import EvaluationPlanClient
 
 
@@ -17,14 +15,14 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.mock_response.json.return_value = {"id": "plan-123", "status": "success"}
         self.mock_response.status_code = 200
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_evaluation_plans(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_evaluation_plans()
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_evaluation_plan_minimal(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.create_evaluation_plan(
@@ -36,7 +34,7 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['evaluationPlanName'], "Test Plan")
         self.assertEqual(call_args[1]['data']['evaluationPlanType'], "TextPromptAssistant")
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_evaluation_plan_with_assistant(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.create_evaluation_plan(
@@ -52,7 +50,7 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['evaluationPlanAssistantName'], "Test Assistant")
         self.assertEqual(call_args[1]['data']['evaluationPlanAssistantRevision'], "1.0")
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_evaluation_plan_with_all_params(self, mock_post):
         mock_post.return_value = self.mock_response
         system_metrics = [{"systemMetricId": "metric-1", "systemMetricWeight": 0.5}]
@@ -69,14 +67,14 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['dataSetId'], "dataset-123")
         self.assertEqual(call_args[1]['data']['systemMetrics'], system_metrics)
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_evaluation_plan(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_evaluation_plan("plan-123")
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_evaluation_plan_name_only(self, mock_put):
         mock_put.return_value = self.mock_response
         result = self.client.update_evaluation_plan(
@@ -88,7 +86,7 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['evaluationPlanName'], "Updated Plan")
         self.assertEqual(len(call_args[1]['data']), 1)
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_evaluation_plan_multiple_fields(self, mock_put):
         mock_put.return_value = self.mock_response
         system_metrics = [{"systemMetricId": "metric-1", "systemMetricWeight": 0.8}]
@@ -110,21 +108,21 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['evaluationPlanAssistantId'], "asst-456")
         self.assertEqual(call_args[1]['data']['systemMetrics'], system_metrics)
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_evaluation_plan(self, mock_delete):
         mock_delete.return_value = self.mock_response
         result = self.client.delete_evaluation_plan("plan-123")
         mock_delete.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_evaluation_plan_system_metrics(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_evaluation_plan_system_metrics("plan-123")
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_add_evaluation_plan_system_metric(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.add_evaluation_plan_system_metric(
@@ -137,7 +135,7 @@ class TestEvaluationPlanClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['systemMetricId'], "metric-456")
         self.assertEqual(call_args[1]['data']['systemMetricWeight'], 0.75)
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_evaluation_plan_system_metric(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_evaluation_plan_system_metric(
@@ -147,7 +145,7 @@ class TestEvaluationPlanClient(unittest.TestCase):
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_evaluation_plan_system_metric(self, mock_put):
         mock_put.return_value = self.mock_response
         result = self.client.update_evaluation_plan_system_metric(
@@ -159,7 +157,7 @@ class TestEvaluationPlanClient(unittest.TestCase):
         call_args = mock_put.call_args
         self.assertEqual(call_args[1]['data']['systemMetricWeight'], 0.9)
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_evaluation_plan_system_metric(self, mock_delete):
         mock_delete.return_value = self.mock_response
         result = self.client.delete_evaluation_plan_system_metric(
@@ -169,21 +167,21 @@ class TestEvaluationPlanClient(unittest.TestCase):
         mock_delete.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_system_metrics(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.list_system_metrics()
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_system_metric(self, mock_get):
         mock_get.return_value = self.mock_response
         result = self.client.get_system_metric("metric-456")
         mock_get.assert_called_once()
         self.assertEqual(result, {"id": "plan-123", "status": "success"})
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_execute_evaluation_plan(self, mock_post):
         mock_post.return_value = self.mock_response
         result = self.client.execute_evaluation_plan("plan-123")

pygeai/tests/evaluation/result/test_clients.py

@@ -2,7 +2,6 @@ import unittest
 from unittest.mock import patch, MagicMock
 
 from pygeai.evaluation.result.clients import EvaluationResultClient
-from pygeai.core.base.session import Session
 
 
 class TestEvaluationResultClient(unittest.TestCase):
@@ -15,7 +14,7 @@ class TestEvaluationResultClient(unittest.TestCase):
         self.mock_response = MagicMock()
         self.mock_response.status_code = 200
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_evaluation_results_success(self, mock_get):
         self.mock_response.json.return_value = [{"id": "result-1", "status": "completed"}, {"id": "result-2", "status": "pending"}]
         mock_get.return_value = self.mock_response
@@ -27,7 +26,7 @@ class TestEvaluationResultClient(unittest.TestCase):
         self.assertEqual(result[0]["id"], "result-1")
         self.assertEqual(result[1]["id"], "result-2")
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_list_evaluation_results_empty(self, mock_get):
         self.mock_response.json.return_value = []
         mock_get.return_value = self.mock_response
@@ -37,7 +36,7 @@ class TestEvaluationResultClient(unittest.TestCase):
         mock_get.assert_called_once()
         self.assertEqual(result, [])
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_evaluation_result_success(self, mock_get):
         self.mock_response.json.return_value = {"id": "result-123", "status": "completed", "score": 0.95}
         mock_get.return_value = self.mock_response
@@ -49,7 +48,7 @@ class TestEvaluationResultClient(unittest.TestCase):
         self.assertEqual(result["status"], "completed")
         self.assertEqual(result["score"], 0.95)
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_evaluation_result_with_details(self, mock_get):
         self.mock_response.json.return_value = {"id": "result-789", "status": "failed", "error": "Test error"}
         mock_get.return_value = self.mock_response

pygeai/tests/health/test_clients.py

@@ -15,7 +15,7 @@ class TestHealthClient(unittest.TestCase):
     def setUp(self):
         self.client = HealthClient()
 
-    @patch("pygeai.core.services.rest.ApiService.get")
+    @patch("pygeai.core.services.rest.GEAIApiService.get")
     def test_check_api_status_success(self, mock_get):
         expected_response = {"status": "healthy", "version": "1.0.0"}
         mock_response = mock_get.return_value
@@ -27,7 +27,7 @@ class TestHealthClient(unittest.TestCase):
         self.assertEqual(result, expected_response)
         mock_get.assert_called_once_with(endpoint=STATUS_CHECK_V1)
 
-    @patch("pygeai.core.services.rest.ApiService.get")
+    @patch("pygeai.core.services.rest.GEAIApiService.get")
     def test_check_api_status_json_decode_error(self, mock_get):
         mock_response = mock_get.return_value
         mock_response.status_code = 200

pygeai/tests/integration/lab/agents/test_create_agent.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, Sampling, PromptExample, PromptOutput
-from pydantic import ValidationError
-from pygeai.core.common.exceptions import APIError, InvalidAPIResponseException 
+from pygeai.core.common.exceptions import APIError 
 
 
 class TestAILabCreateAgentIntegration(TestCase):    

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

@@ -1,7 +1,7 @@
 from unittest import TestCase
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import Agent, FilterSettings
-from pygeai.core.common.exceptions import MissingRequirementException, APIError
+from pygeai.core.common.exceptions import APIError
 import copy
 
 ai_lab_manager: AILabManager

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

@@ -4,9 +4,9 @@ import uuid
 from pygeai.lab.managers import AILabManager
 from pygeai.lab.models import (
     AgenticProcess, KnowledgeBase, AgenticActivity, ArtifactSignal, Task, 
-    UserSignal, Event, SequenceFlow, Variable
+    UserSignal, Event, SequenceFlow
 )
-from pygeai.core.common.exceptions import APIResponseError, APIError
+from pygeai.core.common.exceptions import APIError
 
 
 class TestAILabCreateProcessIntegration(TestCase):