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

pygeai/tests/core/embeddings/test_clients.py

@@ -0,0 +1,225 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pygeai.core.embeddings.clients import EmbeddingsClient
+
+
+class TestEmbeddingsClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.embeddings.test_clients.TestEmbeddingsClient
+    """
+
+    def setUp(self):
+        self.client = EmbeddingsClient()
+        self.input_list = ["test input"]
+        self.model = "test-model"
+
+    def test_generate_embeddings_basic(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(input_list=self.input_list, model=self.model)
+
+            mock_api_service.post.assert_called_once()
+            self.assertEqual(result["model"], self.model)
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_with_all_parameters(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="float",
+                dimensions=128,
+                user="test-user",
+                input_type="text",
+                timeout=30,
+                cache=True
+            )
+
+            mock_api_service.post.assert_called_once()
+            call_args = mock_api_service.post.call_args
+            self.assertEqual(call_args[1]["data"]["model"], self.model)
+            self.assertEqual(call_args[1]["data"]["input"], self.input_list)
+            self.assertEqual(call_args[1]["data"]["encoding_format"], "float")
+            self.assertEqual(call_args[1]["data"]["dimensions"], 128)
+            self.assertEqual(call_args[1]["data"]["user"], "test-user")
+            self.assertEqual(call_args[1]["data"]["input_type"], "text")
+            self.assertEqual(call_args[1]["data"]["timeout"], 30)
+            self.assertEqual(call_args[1]["headers"]["X-Saia-Cache-Enabled"], "true")
+            self.assertEqual(result["model"], self.model)
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_without_optional_parameters(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                cache=False
+            )
+
+            mock_api_service.post.assert_called_once()
+            call_args = mock_api_service.post.call_args
+            self.assertEqual(call_args[1]["data"]["model"], self.model)
+            self.assertEqual(call_args[1]["data"]["input"], self.input_list)
+            self.assertNotIn("encoding_format", call_args[1]["data"])
+            self.assertNotIn("dimensions", call_args[1]["data"])
+            self.assertNotIn("user", call_args[1]["data"])
+            self.assertNotIn("input_type", call_args[1]["data"])
+            self.assertNotIn("timeout", call_args[1]["data"])
+            self.assertNotIn("X-Saia-Cache-Enabled", call_args[1]["headers"])
+            self.assertEqual(result["model"], self.model)
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_empty_input_list(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=[], model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_none_input_list(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=None, model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_empty_string_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=[""], model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_whitespace_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=["   "], model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_invalid_encoding_format(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="invalid"
+            )
+        self.assertIn("encoding_format must be either 'float' or 'base64'", str(context.exception))
+
+    def test_generate_embeddings_valid_encoding_format_float(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="float"
+            )
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_valid_encoding_format_base64(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": "base64string"}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="base64"
+            )
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_invalid_dimensions(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                dimensions=0
+            )
+        self.assertIn("dimensions must be a positive integer", str(context.exception))
+
+    def test_generate_embeddings_negative_dimensions(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                dimensions=-10
+            )
+        self.assertIn("dimensions must be a positive integer", str(context.exception))
+
+    def test_generate_embeddings_valid_dimensions(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1] * 512}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                dimensions=512
+            )
+            call_args = mock_api_service.post.call_args
+            self.assertEqual(call_args[1]["data"]["dimensions"], 512)
+
+    def test_generate_embeddings_multiple_inputs(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {
+            
+                "model": self.model,
+                "data": [
+                    {"index": 0, "embedding": [0.1, 0.2]},
+                    {"index": 1, "embedding": [0.3, 0.4]},
+                    {"index": 2, "embedding": [0.5, 0.6]}
+                ]
+            }
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=["input1", "input2", "input3"],
+                model=self.model
+            )
+            self.assertEqual(len(result["data"]), 3)
+
+    def test_generate_embeddings_with_cache_enabled(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                cache=True
+            )
+            call_args = mock_api_service.post.call_args
+            self.assertEqual(call_args[1]["headers"]["X-Saia-Cache-Enabled"], "true")
+
+    def test_generate_embeddings_with_cache_disabled(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                cache=False
+            )
+            call_args = mock_api_service.post.call_args
+            self.assertNotIn("X-Saia-Cache-Enabled", call_args[1]["headers"])

pygeai/tests/core/embeddings/test_managers.py

@@ -0,0 +1,171 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.embeddings.responses import EmbeddingResponse
+from pygeai.core.common.exceptions import APIError
+
+
+class TestEmbeddingsManager(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.embeddings.test_managers.TestEmbeddingsManager
+    """
+
+    def setUp(self):
+        self.manager = EmbeddingsManager()
+        self.config = EmbeddingConfiguration(
+            inputs=["test input"],
+            model="test-model"
+        )
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_success(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [
+                {
+                    "index": 0,
+                    "embedding": [0.1, 0.2, 0.3],
+                    "object": "embedding"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        result = self.manager.generate_embeddings(self.config)
+
+        self.assertIsInstance(result, EmbeddingResponse)
+        self.assertEqual(result.model, "test-model")
+        self.assertEqual(len(result.data), 1)
+        self.assertEqual(result.data[0].index, 0)
+        self.assertEqual(result.usage.prompt_tokens, 5)
+        self.assertEqual(result.usage.total_cost, 0.0001)
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_with_all_config_parameters(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [{"index": 0, "embedding": [0.1], "object": "embedding"}],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        config = EmbeddingConfiguration(
+            inputs=["test"],
+            model="test-model",
+            encoding_format="base64",
+            dimensions=512,
+            user="user123",
+            input_type="query",
+            timeout=30,
+            cache=True
+        )
+
+        result = self.manager.generate_embeddings(config)
+
+        mock_generate.assert_called_once_with(
+            input_list=["test"],
+            model="test-model",
+            encoding_format="base64",
+            dimensions=512,
+            user="user123",
+            input_type="query",
+            timeout=30,
+            cache=True
+        )
+        self.assertIsInstance(result, EmbeddingResponse)
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_with_error(self, mock_generate):
+        mock_generate.return_value = {
+            "error": {
+                "message": "Invalid model",
+                "type": "invalid_request_error"
+            }
+        }
+
+        with self.assertRaises(APIError) as context:
+            self.manager.generate_embeddings(self.config)
+
+        self.assertIn("Error received while generating embeddings", str(context.exception))
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_multiple_inputs(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [
+                {"index": 0, "embedding": [0.1, 0.2], "object": "embedding"},
+                {"index": 1, "embedding": [0.3, 0.4], "object": "embedding"}
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "total_tokens": 10,
+                "total_cost": 0.0002,
+                "currency": "USD",
+                "prompt_cost": 0.0002,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        config = EmbeddingConfiguration(
+            inputs=["input1", "input2"],
+            model="test-model"
+        )
+
+        result = self.manager.generate_embeddings(config)
+
+        self.assertEqual(len(result.data), 2)
+        self.assertEqual(result.data[0].index, 0)
+        self.assertEqual(result.data[1].index, 1)
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_with_token_details(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [{"index": 0, "embedding": [0.1], "object": "embedding"}],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": {
+                    "reasoning_tokens": 0,
+                    "cached_tokens": 0
+                },
+                "prompt_tokens_details": {
+                    "reasoning_tokens": 0,
+                    "cached_tokens": 5
+                }
+            }
+        }
+
+        result = self.manager.generate_embeddings(self.config)
+
+        self.assertIsNotNone(result.usage.completion_tokens_details)
+        self.assertIsNotNone(result.usage.prompt_tokens_details)
+        self.assertEqual(result.usage.prompt_tokens_details.cached_tokens, 5)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/core/embeddings/test_mappers.py

@@ -0,0 +1,142 @@
+import unittest
+from pygeai.core.embeddings.mappers import EmbeddingsResponseMapper
+from pygeai.core.embeddings.responses import EmbeddingResponse, EmbeddingData, UsageInfo, TokenDetails
+
+
+class TestEmbeddingsResponseMapper(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.embeddings.test_mappers.TestEmbeddingsResponseMapper
+    """
+
+    def test_map_to_embedding_response_basic(self):
+        data = {
+            "model": "test-model",
+            "object": "list",
+            "data": [
+                {
+                    "index": 0,
+                    "embedding": [0.1, 0.2, 0.3],
+                    "object": "embedding"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        result = EmbeddingsResponseMapper.map_to_embedding_response(data)
+
+        self.assertIsInstance(result, EmbeddingResponse)
+        self.assertEqual(result.model, "test-model")
+        self.assertEqual(result.object, "list")
+        self.assertEqual(len(result.data), 1)
+        self.assertEqual(result.data[0].index, 0)
+        self.assertEqual(result.data[0].embedding, [0.1, 0.2, 0.3])
+
+    def test_map_to_embedding_data_list(self):
+        data = [
+            {"index": 0, "embedding": [0.1, 0.2], "object": "embedding"},
+            {"index": 1, "embedding": [0.3, 0.4], "object": "embedding"}
+        ]
+
+        result = EmbeddingsResponseMapper.map_to_embedding_data_list(data)
+
+        self.assertEqual(len(result), 2)
+        self.assertIsInstance(result[0], EmbeddingData)
+        self.assertEqual(result[0].index, 0)
+        self.assertEqual(result[1].index, 1)
+
+    def test_map_to_embedding_data_with_base64(self):
+        data = [
+            {"index": 0, "embedding": "base64string==", "object": "embedding"}
+        ]
+
+        result = EmbeddingsResponseMapper.map_to_embedding_data_list(data)
+
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0].embedding, "base64string==")
+        self.assertIsInstance(result[0].embedding, str)
+
+    def test_map_to_usage_info_basic(self):
+        data = {
+            "prompt_tokens": 10,
+            "total_tokens": 10,
+            "total_cost": 0.0002,
+            "currency": "USD",
+            "prompt_cost": 0.0002,
+            "completion_tokens_details": None,
+            "prompt_tokens_details": None
+        }
+
+        result = EmbeddingsResponseMapper.map_to_usage_info(data)
+
+        self.assertIsInstance(result, UsageInfo)
+        self.assertEqual(result.prompt_tokens, 10)
+        self.assertEqual(result.total_tokens, 10)
+        self.assertEqual(result.total_cost, 0.0002)
+        self.assertEqual(result.currency, "USD")
+        self.assertEqual(result.prompt_cost, 0.0002)
+        self.assertIsNone(result.completion_tokens_details)
+        self.assertIsNone(result.prompt_tokens_details)
+
+    def test_map_to_usage_info_with_token_details(self):
+        data = {
+            "prompt_tokens": 10,
+            "total_tokens": 10,
+            "total_cost": 0.0002,
+            "currency": "USD",
+            "prompt_cost": 0.0002,
+            "completion_tokens_details": {
+                "reasoning_tokens": 0,
+                "cached_tokens": 0
+            },
+            "prompt_tokens_details": {
+                "reasoning_tokens": 0,
+                "cached_tokens": 5
+            }
+        }
+
+        result = EmbeddingsResponseMapper.map_to_usage_info(data)
+
+        self.assertIsNotNone(result.completion_tokens_details)
+        self.assertIsNotNone(result.prompt_tokens_details)
+        self.assertIsInstance(result.completion_tokens_details, TokenDetails)
+        self.assertIsInstance(result.prompt_tokens_details, TokenDetails)
+        self.assertEqual(result.prompt_tokens_details.cached_tokens, 5)
+
+    def test_parse_token_details_with_none(self):
+        result = EmbeddingsResponseMapper._parse_token_details(None)
+        self.assertIsNone(result)
+
+    def test_parse_token_details_with_data(self):
+        data = {
+            "reasoning_tokens": 10,
+            "cached_tokens": 5
+        }
+
+        result = EmbeddingsResponseMapper._parse_token_details(data)
+
+        self.assertIsInstance(result, TokenDetails)
+        self.assertEqual(result.reasoning_tokens, 10)
+        self.assertEqual(result.cached_tokens, 5)
+
+    def test_map_to_embedding_response_with_missing_fields(self):
+        data = {
+            "model": "test-model"
+        }
+
+        result = EmbeddingsResponseMapper.map_to_embedding_response(data)
+
+        self.assertEqual(result.model, "test-model")
+        self.assertEqual(result.object, "")
+        self.assertEqual(len(result.data), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/core/feedback/test_clients.py

@@ -0,0 +1,64 @@
+import unittest
+from unittest.mock import patch, Mock
+from pygeai.core.feedback.clients import FeedbackClient
+
+
+class TestFeedbackClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.feedback.test_clients.TestFeedbackClient
+    """
+    def setUp(self):
+        self.feedback_client = FeedbackClient()
+        self.request_id = "test_request_123"
+        self.origin = "user-feedback"
+        self.answer_score = 1
+        self.comments = "Great response!"
+
+    @patch('pygeai.core.services.rest.ApiService.post')
+    def test_send_feedback_without_comments(self, mock_post):
+        mock_response = Mock()
+        mock_response.json.return_value = {}
+        mock_response.status_code = 200
+        mock_post.return_value = mock_response
+
+        result = self.feedback_client.send_feedback(
+            request_id=self.request_id,
+            origin=self.origin,
+            answer_score=self.answer_score
+        )
+
+        expected_data = {
+            "origin": self.origin,
+            "answerScore": self.answer_score
+        }
+        mock_post.assert_called_once_with(
+            endpoint=f"v1/feedback/request/{self.request_id}",
+            data=expected_data
+        )
+        self.assertEqual(result, {})
+
+    @patch('pygeai.core.services.rest.ApiService.post')
+    def test_send_feedback_with_comments(self, mock_post):
+        mock_response = Mock()
+        mock_response.json.return_value = {}
+        mock_response.status_code = 200
+        mock_post.return_value = mock_response
+
+        result = self.feedback_client.send_feedback(
+            request_id=self.request_id,
+            origin=self.origin,
+            answer_score=self.answer_score,
+            comments=self.comments
+        )
+
+        expected_data = {
+            "origin": self.origin,
+            "answerScore": self.answer_score,
+            "comments": self.comments
+        }
+        mock_post.assert_called_once_with(
+            endpoint=f"v1/feedback/request/{self.request_id}",
+            data=expected_data
+        )
+        self.assertEqual(result, {})
+