embed-client 0.0.1__tar.gz → 1.0.0__tar.gz

{embed_client-0.0.1 → embed_client-1.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: embed-client
-Version: 0.0.1
+Version: 1.0.0
 Summary: Async client for Embedding Service API
 Author: Your Name
 Requires-Dist: aiohttp

{embed_client-0.0.1 → embed_client-1.0.0}/embed_client/async_client.py

@@ -8,6 +8,7 @@ Async client for Embedding Service API (OpenAPI 3.0.2)
 
 from typing import Any, Dict, List, Optional, Union
 import aiohttp
+import os
 
 class EmbeddingServiceError(Exception):
     """Base exception for EmbeddingServiceAsyncClient."""
@@ -37,13 +38,13 @@ class EmbeddingServiceAsyncClient:
     Raises:
         ValueError: If base_url or port is not provided.
     """
-    def __init__(self, base_url: str, port: int):
-        if not base_url:
+    def __init__(self, base_url: Optional[str] = None, port: Optional[int] = None):
+        self.base_url = base_url or os.getenv("EMBEDDING_SERVICE_BASE_URL", "http://localhost")
+        if not self.base_url:
             raise ValueError("base_url must be provided.")
-        if port is None:
+        self.port = port or int(os.getenv("EMBEDDING_SERVICE_PORT", "8001"))
+        if self.port is None:
             raise ValueError("port must be provided.")
-        self.base_url = base_url.rstrip("/")
-        self.port = port
         self._session: Optional[aiohttp.ClientSession] = None
 
     def _make_url(self, path: str, base_url: Optional[str] = None, port: Optional[int] = None) -> str:
@@ -51,6 +52,23 @@ class EmbeddingServiceAsyncClient:
         port_val = port if port is not None else self.port
         return f"{url}:{port_val}{path}"
 
+    def _format_error_response(self, error: str, lang: Optional[str] = None, text: Optional[str] = None) -> Dict[str, Any]:
+        """
+        Format error response in a standard way.
+        Args:
+            error (str): Error message
+            lang (str, optional): Language of the text that caused the error
+            text (str, optional): Text that caused the error
+        Returns:
+            dict: Formatted error response
+        """
+        response = {"error": f"Embedding service error: {error}"}
+        if lang is not None:
+            response["lang"] = lang
+        if text is not None:
+            response["text"] = text
+        return response
+
     async def __aenter__(self):
         self._session = aiohttp.ClientSession()
         return self
@@ -144,8 +162,25 @@ class EmbeddingServiceAsyncClient:
             base_url (str, optional): Override base URL.
             port (int, optional): Override port.
         Returns:
-            dict: Command execution result.
+            dict: Command execution result or error response in format:
+                {
+                    "error": {
+                        "code": <код ошибки>,
+                        "message": <сообщение об ошибке>
+                    }
+                }
+                или
+                {
+                    "result": {
+                        "success": true,
+                        "data": {
+                            "embeddings": [[...], ...]
+                        }
+                    }
+                }
         """
+        if not command:
+            raise EmbeddingServiceAPIError("Command is required")
         url = self._make_url("/cmd", base_url, port)
         payload = {"command": command}
         if params is not None:
@@ -154,22 +189,22 @@ class EmbeddingServiceAsyncClient:
             async with self._session.post(url, json=payload) as resp:
                 await self._raise_for_status(resp)
                 data = await resp.json()
-                # Обработка ошибок, возвращаемых сервером в теле ответа
                 if "error" in data:
                     raise EmbeddingServiceAPIError(data["error"])
+                if "result" in data:
+                    res = data["result"]
+                    if isinstance(res, dict) and "success" in res and res["success"] is False:
+                        if "error" in res:
+                            raise EmbeddingServiceAPIError(res["error"])
                 return data
-        except EmbeddingServiceAPIError:
-            raise
-        except EmbeddingServiceHTTPError:
-            raise
-        except EmbeddingServiceConnectionError:
-            raise
         except aiohttp.ClientConnectionError as e:
-            raise EmbeddingServiceConnectionError(f"Connection error: {e}") from e
+            raise EmbeddingServiceAPIError(f"Connection error: {e}") from e
         except aiohttp.ClientResponseError as e:
             raise EmbeddingServiceHTTPError(e.status, e.message) from e
+        except EmbeddingServiceHTTPError:
+            raise
         except Exception as e:
-            raise EmbeddingServiceError(f"Unexpected error: {e}") from e
+            raise EmbeddingServiceAPIError(f"Unexpected error: {e}") from e
 
     async def _raise_for_status(self, resp: aiohttp.ClientResponse):
         try:

embed_client-1.0.0/embed_client/example_async_usage.py

@@ -0,0 +1,69 @@
+"""
+Example usage of EmbeddingServiceAsyncClient.
+
+This example demonstrates how to use the async client to check the health of the embedding service,
+request embeddings, and handle all possible errors.
+
+Run this script with:
+    python -m asyncio embed_client/example_async_usage.py --base-url http://localhost --port 8001
+
+You can also set EMBED_CLIENT_BASE_URL and EMBED_CLIENT_PORT environment variables.
+"""
+
+import asyncio
+import sys
+import os
+from embed_client.async_client import EmbeddingServiceAsyncClient
+
+def get_params():
+    base_url = None
+    port = None
+    for i, arg in enumerate(sys.argv):
+        if arg in ("--base-url", "-b") and i + 1 < len(sys.argv):
+            base_url = sys.argv[i + 1]
+        if arg in ("--port", "-p") and i + 1 < len(sys.argv):
+            port = sys.argv[i + 1]
+    if not base_url:
+        base_url = os.environ.get("EMBED_CLIENT_BASE_URL")
+    if not port:
+        port = os.environ.get("EMBED_CLIENT_PORT")
+    if not base_url or not port:
+        print("Error: base_url and port must be provided via --base-url/--port arguments or EMBED_CLIENT_BASE_URL/EMBED_CLIENT_PORT environment variables.")
+        sys.exit(1)
+        return None, None
+    return base_url, int(port)
+
+async def main():
+    base_url, port = get_params()
+    async with EmbeddingServiceAsyncClient(base_url=base_url, port=port) as client:
+        # Check health
+        health = await client.health()
+        print("Service health:", health)
+
+        # Request embeddings for a list of texts
+        texts = ["hello world", "test embedding"]
+        result = await client.cmd("embed", params={"texts": texts})
+        
+        if "error" in result:
+            print(f"Error occurred: {result['error']}")
+            if "lang" in result:
+                print(f"Language: {result['lang']}")
+            if "text" in result:
+                print(f"Text: {result['text']}")
+        else:
+            vectors = result["result"]
+            print(f"Embeddings for {len(texts)} texts:")
+            for i, vec in enumerate(vectors):
+                print(f"  Text: {texts[i]!r}\n  Vector: {vec[:5]}... (total {len(vec)} dims)")
+
+        # Example: error handling for invalid command
+        result = await client.cmd("health")
+        print("Health check result:", result)
+
+        # Example: error handling for empty command
+        # result = await client.cmd("")
+        # if "error" in result:
+        #     print(f"Error for empty command: {result['error']}")
+
+if __name__ == "__main__":
+    asyncio.run(main()) 

{embed_client-0.0.1 → embed_client-1.0.0}/embed_client.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: embed-client
-Version: 0.0.1
+Version: 1.0.0
 Summary: Async client for Embedding Service API
 Author: Your Name
 Requires-Dist: aiohttp

{embed_client-0.0.1 → embed_client-1.0.0}/embed_client.egg-info/SOURCES.txt

@@ -11,5 +11,6 @@ embed_client.egg-info/requires.txt
 embed_client.egg-info/top_level.txt
 tests/test_async_client.py
 tests/test_async_client_real.py
+tests/test_async_client_stress.py
 tests/test_example_async_usage.py
 tests/test_example_async_usage_ru.py

{embed_client-0.0.1 → embed_client-1.0.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "embed-client"
-version = "0.0.1"
+version = "1.0.0"
 description = "Async client for Embedding Service API"
 authors = [{name = "Your Name"}]
 dependencies = [

{embed_client-0.0.1 → embed_client-1.0.0}/tests/test_async_client.py

@@ -2,6 +2,7 @@ import pytest
 import pytest_asyncio
 from unittest.mock import patch, MagicMock
 from embed_client.async_client import EmbeddingServiceAsyncClient, EmbeddingServiceAPIError, EmbeddingServiceHTTPError, EmbeddingServiceError, EmbeddingServiceConnectionError
+import aiohttp
 
 BASE_URL = "http://testserver"
 PORT = 1234
@@ -67,18 +68,80 @@ async def test_cmd(client):
         mock_post.assert_called_with(make_url("/cmd"), json={"command": "embed", "params": {"texts": ["abc"]}})
 
 @pytest.mark.asyncio
-async def test_init_requires_base_url_and_port():
-    with pytest.raises(ValueError):
-        EmbeddingServiceAsyncClient(base_url=None, port=PORT)
-    with pytest.raises(ValueError):
-        EmbeddingServiceAsyncClient(base_url=BASE_URL, port=None)
+async def test_init_requires_base_url_and_port(monkeypatch):
+    # Сохраняем и очищаем переменные окружения
+    monkeypatch.delenv("EMBEDDING_SERVICE_BASE_URL", raising=False)
+    monkeypatch.delenv("EMBEDDING_SERVICE_PORT", raising=False)
+    # Если не передано ничего и нет переменных окружения, будет дефолт
+    client = EmbeddingServiceAsyncClient()
+    assert client.base_url == "http://localhost"
+    assert client.port == 8001
+    # Если явно передан base_url и port
+    client2 = EmbeddingServiceAsyncClient(base_url="http://test", port=1234)
+    assert client2.base_url == "http://test"
+    assert client2.port == 1234
+
+@pytest.mark.asyncio
+async def test_cmd_empty_command(client):
+    with pytest.raises(EmbeddingServiceAPIError) as excinfo:
+        await client.cmd("")
+    assert "Command is required" in str(excinfo.value)
+
+@pytest.mark.asyncio
+async def test_cmd_connection_error(client):
+    with patch.object(client._session, 'post', side_effect=aiohttp.ClientConnectionError("Connection failed")):
+        with pytest.raises(EmbeddingServiceAPIError) as excinfo:
+            await client.cmd("embed", params={"texts": ["abc"]})
+        assert "Connection error" in str(excinfo.value)
+
+@pytest.mark.asyncio
+async def test_cmd_http_error(client):
+    with patch.object(client._session, 'post', side_effect=aiohttp.ClientResponseError(
+        request_info=MagicMock(),
+        history=(),
+        status=500,
+        message="Internal Server Error"
+    )):
+        with pytest.raises(EmbeddingServiceHTTPError) as excinfo:
+            await client.cmd("embed", params={"texts": ["abc"]})
+        assert "HTTP 500" in str(excinfo.value)
+
+@pytest.mark.asyncio
+async def test_cmd_api_error(client):
+    mock_response = MockAiohttpResponse(json_data={"error": "Invalid command"})
+    with patch.object(client._session, 'post', return_value=mock_response):
+        with pytest.raises(EmbeddingServiceAPIError) as excinfo:
+            await client.cmd("invalid_command")
+        assert "Invalid command" in str(excinfo.value)
+
+@pytest.mark.asyncio
+async def test_cmd_with_lang_and_text(client):
+    mock_response = MockAiohttpResponse(json_data={"error": "Invalid text"})
+    with patch.object(client._session, 'post', return_value=mock_response):
+        with pytest.raises(EmbeddingServiceAPIError) as excinfo:
+            await client.cmd("embed", params={
+                "texts": ["test"],
+                "lang": "en",
+                "text": "test text"
+            })
+        assert "Invalid text" in str(excinfo.value)
+
+@pytest.mark.asyncio
+async def test_cmd_success(client):
+    mock_response = MockAiohttpResponse(json_data={"result": [[1.0, 2.0, 3.0]]})
+    with patch.object(client._session, 'post', return_value=mock_response):
+        result = await client.cmd("embed", params={"texts": ["test"]})
+        assert "result" in result
+        assert result["result"] == [[1.0, 2.0, 3.0]]
 
 # Некорректные параметры: не-строка в texts
 @pytest.mark.asyncio
 async def test_embed_non_string_text(client):
-    with patch.object(client._session, 'post', return_value=MockAiohttpResponse({"error": {"code": 422, "message": "Invalid input"}})) as mock_post:
-        with pytest.raises(EmbeddingServiceAPIError):
+    mock_response = MockAiohttpResponse(json_data={"error": {"code": 422, "message": "Invalid input"}})
+    with patch.object(client._session, 'post', return_value=mock_response) as mock_post:
+        with pytest.raises(EmbeddingServiceAPIError) as excinfo:
             await client.cmd("embed", params={"texts": [123, "ok"]})
+        assert "Invalid input" in str(excinfo.value)
 
 # Некорректные параметры: невалидный params
 @pytest.mark.asyncio
@@ -183,25 +246,6 @@ async def test_get_commands_unexpected_error(client):
         with pytest.raises(EmbeddingServiceError):
             await client.get_commands()
 
-# Аналогично для cmd
-@pytest.mark.asyncio
-async def test_cmd_http_error(client):
-    with patch.object(client._session, 'post', side_effect=EmbeddingServiceHTTPError(500, "fail")):
-        with pytest.raises(EmbeddingServiceHTTPError):
-            await client.cmd("embed", params={"texts": ["abc"]})
-
-@pytest.mark.asyncio
-async def test_cmd_connection_error(client):
-    with patch.object(client._session, 'post', side_effect=EmbeddingServiceConnectionError("fail")):
-        with pytest.raises(EmbeddingServiceConnectionError):
-            await client.cmd("embed", params={"texts": ["abc"]})
-
-@pytest.mark.asyncio
-async def test_cmd_unexpected_error(client):
-    with patch.object(client._session, 'post', side_effect=ValueError("fail")):
-        with pytest.raises(EmbeddingServiceError):
-            await client.cmd("embed", params={"texts": ["abc"]})
-
 # Покрытие: _raise_for_status - ClientResponseError
 @pytest.mark.asyncio
 async def test_raise_for_status_http_error():

{embed_client-0.0.1 → embed_client-1.0.0}/tests/test_async_client_real.py

@@ -58,12 +58,22 @@ def extract_vectors(result):
     elif "result" in result:
         if isinstance(result["result"], list):
             return result["result"]
-        elif isinstance(result["result"], dict) and "embeddings" in result["result"]:
+        elif (
+            isinstance(result["result"], dict)
+            and "embeddings" in result["result"]
+        ):
             return result["result"]["embeddings"]
+        elif (
+            isinstance(result["result"], dict)
+            and "data" in result["result"]
+            and isinstance(result["result"]["data"], dict)
+            and "embeddings" in result["result"]["data"]
+        ):
+            return result["result"]["data"]["embeddings"]
         else:
             pytest.fail("No embeddings in result['result']")
     else:
-        pytest.fail("No embeddings or result in response")
+        pytest.fail("No embeddings in result")
 
 @pytest.mark.asyncio
 @pytest.mark.integration
@@ -84,10 +94,9 @@ async def test_real_embed_vector(real_client):
 async def test_real_embed_empty_texts(real_client):
     if not await is_service_available():
         pytest.skip("Real service on localhost:8001 is not available.")
-    result = await real_client.cmd("embed", params={"texts": []})
-    vectors = extract_vectors(result)
-    assert isinstance(vectors, list)
-    assert len(vectors) == 0
+    with pytest.raises(EmbeddingServiceAPIError) as excinfo:
+        await real_client.cmd("embed", params={"texts": []})
+    assert "Empty texts list provided" in str(excinfo.value)
 
 @pytest.mark.asyncio
 @pytest.mark.integration

embed_client-1.0.0/tests/test_async_client_stress.py

@@ -0,0 +1,303 @@
+"""
+Stress tests for EmbeddingServiceAsyncClient.
+
+These tests verify the client's behavior under heavy load with parallel processing
+of large text batches.
+"""
+
+import pytest
+import pytest_asyncio
+import asyncio
+import time
+import random
+from typing import List, Dict, Any, Optional
+from embed_client.async_client import EmbeddingServiceAsyncClient
+
+BASE_URL = "http://localhost"
+PORT = 8001
+
+# Constants for retry logic
+MAX_RETRIES = 3
+RETRY_DELAY = 1.0  # seconds
+MAX_CONCURRENT_TASKS = 100  # Limit concurrent tasks to prevent system overload
+
+def generate_test_texts(count: int) -> List[str]:
+    """Generate test texts with unique content."""
+    return [f"Test text {i} for stress testing" for i in range(count)]
+
+async def process_with_retry(
+    client: EmbeddingServiceAsyncClient,
+    texts: List[str],
+    max_retries: int = MAX_RETRIES,
+    retry_delay: float = RETRY_DELAY
+) -> Dict[str, Any]:
+    """
+    Process texts with retry logic for handling runtime exceptions.
+    
+    Args:
+        client: EmbeddingServiceAsyncClient instance
+        texts: List of texts to process
+        max_retries: Maximum number of retry attempts
+        retry_delay: Delay between retries in seconds
+        
+    Returns:
+        Dict containing the result or error information
+    """
+    for attempt in range(max_retries):
+        try:
+            return await client.cmd("embed", params={"texts": texts})
+        except Exception as e:
+            if attempt == max_retries - 1:  # Last attempt
+                return {
+                    "error": f"Failed after {max_retries} attempts: {str(e)}",
+                    "exception": str(e),
+                    "attempts": attempt + 1
+                }
+            await asyncio.sleep(retry_delay * (attempt + 1))  # Exponential backoff
+
+async def process_batch(
+    client: EmbeddingServiceAsyncClient,
+    texts: List[str],
+    batch_size: int,
+    max_concurrent: int = MAX_CONCURRENT_TASKS
+) -> List[Dict[str, Any]]:
+    """
+    Process a batch of texts in parallel with controlled concurrency.
+    
+    Args:
+        client: EmbeddingServiceAsyncClient instance
+        texts: List of texts to process
+        batch_size: Size of each batch
+        max_concurrent: Maximum number of concurrent tasks
+        
+    Returns:
+        List of results for each batch
+    """
+    semaphore = asyncio.Semaphore(max_concurrent)
+    
+    async def process_with_semaphore(batch: List[str]) -> Dict[str, Any]:
+        async with semaphore:
+            return await process_with_retry(client, batch)
+    
+    tasks = []
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i:i + batch_size]
+        task = asyncio.create_task(process_with_semaphore(batch))
+        tasks.append(task)
+    
+    return await asyncio.gather(*tasks, return_exceptions=True)
+
+@pytest_asyncio.fixture
+async def stress_client():
+    """Create a client instance for stress testing."""
+    async with EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT) as client:
+        yield client
+
+@pytest.mark.asyncio
+@pytest.mark.stress
+async def test_parallel_processing(stress_client):
+    """Test parallel processing of 10K texts."""
+    total_texts = 10_000
+    batch_size = 100  # Process 100 texts at a time
+    texts = generate_test_texts(total_texts)
+    
+    start_time = time.time()
+    results = await process_batch(stress_client, texts, batch_size)
+    end_time = time.time()
+    
+    # Verify results
+    success_count = 0
+    error_count = 0
+    exception_count = 0
+    
+    for result in results:
+        if isinstance(result, Exception):
+            exception_count += 1
+            continue
+        # Сначала assert на error/result
+        assert ("error" in result) or ("result" in result), f"Neither 'error' nor 'result' in response: {result}"
+        if "error" in result:
+            error_count += 1
+            if "exception" in result:
+                print(f"Error with exception: {result['error']}")
+        elif "result" in result:
+            res = result["result"]
+            assert isinstance(res, dict), f"result is not a dict: {res}"
+            if "success" in res and res["success"] is False:
+                error_count += 1
+                if "error" in res:
+                    print(f"Error in result: {res['error']}")
+            else:
+                success_count += 1
+                assert "data" in res, f"No 'data' in result: {res}"
+                data = res["data"]
+                assert isinstance(data, dict), f"data is not a dict: {data}"
+                assert "embeddings" in data, f"No 'embeddings' in data: {data}"
+                assert isinstance(data["embeddings"], list), f"'embeddings' is not a list: {data}"
+    
+    # Calculate statistics
+    total_time = end_time - start_time
+    texts_per_second = total_texts / total_time
+    
+    print(f"\nStress Test Results:")
+    print(f"Total texts processed: {total_texts}")
+    print(f"Successful batches: {success_count}")
+    print(f"Failed batches: {error_count}")
+    print(f"Exception batches: {exception_count}")
+    print(f"Total time: {total_time:.2f} seconds")
+    print(f"Processing speed: {texts_per_second:.2f} texts/second")
+    
+    # Assertions
+    assert success_count > 0, "No successful batches processed"
+    assert total_time > 0, "Invalid processing time"
+    # Allow some errors and exceptions under stress
+    assert error_count + exception_count < total_texts * 0.1, "Too many errors/exceptions"
+
+@pytest.mark.asyncio
+@pytest.mark.stress
+async def test_concurrent_connections(stress_client):
+    """Test multiple concurrent connections to the service."""
+    total_connections = 50
+    texts_per_connection = 200
+    texts = generate_test_texts(texts_per_connection)
+    
+    async def single_connection() -> Dict[str, Any]:
+        try:
+            async with EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT) as client:
+                return await process_with_retry(client, texts)
+        except Exception as e:
+            return {
+                "error": f"Connection failed: {str(e)}",
+                "exception": str(e)
+            }
+    
+    start_time = time.time()
+    tasks = [asyncio.create_task(single_connection()) for _ in range(total_connections)]
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    end_time = time.time()
+    
+    # Verify results
+    success_count = 0
+    error_count = 0
+    exception_count = 0
+    
+    for result in results:
+        if isinstance(result, Exception):
+            exception_count += 1
+            continue
+        # Сначала assert на error/result
+        assert ("error" in result) or ("result" in result), f"Neither 'error' nor 'result' in response: {result}"
+        if "error" in result:
+            error_count += 1
+            if "exception" in result:
+                print(f"Error with exception: {result['error']}")
+        elif "result" in result:
+            res = result["result"]
+            assert isinstance(res, dict), f"result is not a dict: {res}"
+            if "success" in res and res["success"] is False:
+                error_count += 1
+                if "error" in res:
+                    print(f"Error in result: {res['error']}")
+            else:
+                success_count += 1
+                assert "data" in res, f"No 'data' in result: {res}"
+                data = res["data"]
+                assert isinstance(data, dict), f"data is not a dict: {data}"
+                assert "embeddings" in data, f"No 'embeddings' in data: {data}"
+                assert isinstance(data["embeddings"], list), f"'embeddings' is not a list: {data}"
+    
+    # Calculate statistics
+    total_time = end_time - start_time
+    total_texts = total_connections * texts_per_connection
+    texts_per_second = total_texts / total_time
+    
+    print(f"\nConcurrent Connections Test Results:")
+    print(f"Total connections: {total_connections}")
+    print(f"Texts per connection: {texts_per_connection}")
+    print(f"Total texts processed: {total_texts}")
+    print(f"Successful connections: {success_count}")
+    print(f"Failed connections: {error_count}")
+    print(f"Exception connections: {exception_count}")
+    print(f"Total time: {total_time:.2f} seconds")
+    print(f"Processing speed: {texts_per_second:.2f} texts/second")
+    
+    # Assertions
+    assert success_count > 0, "No successful connections"
+    assert total_time > 0, "Invalid processing time"
+    # Allow some errors and exceptions under stress
+    assert error_count + exception_count < total_connections * 0.2, "Too many errors/exceptions"
+
+@pytest.mark.asyncio
+@pytest.mark.stress
+async def test_error_handling_under_load(stress_client):
+    """Test error handling under load with mixed valid and invalid inputs."""
+    total_texts = 5_000
+    batch_size = 50
+    texts = generate_test_texts(total_texts)
+    
+    # Add some invalid inputs
+    invalid_texts = [None, "", " " * 1000]  # Empty, None, and very long text
+    texts.extend(invalid_texts)
+    
+    # Add some random delays to simulate real-world conditions
+    async def process_with_delay(batch: List[str]) -> Dict[str, Any]:
+        await asyncio.sleep(random.uniform(0.1, 0.5))
+        return await process_with_retry(stress_client, batch)
+    
+    start_time = time.time()
+    tasks = []
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i:i + batch_size]
+        task = asyncio.create_task(process_with_delay(batch))
+        tasks.append(task)
+    results = await asyncio.gather(*tasks, return_exceptions=True)
+    end_time = time.time()
+    
+    # Verify results
+    success_count = 0
+    error_count = 0
+    exception_count = 0
+    
+    for result in results:
+        if isinstance(result, Exception):
+            exception_count += 1
+            continue
+        # Сначала assert на error/result
+        assert ("error" in result) or ("result" in result), f"Neither 'error' nor 'result' in response: {result}"
+        if "error" in result:
+            error_count += 1
+            if "exception" in result:
+                print(f"Error with exception: {result['error']}")
+        elif "result" in result:
+            res = result["result"]
+            assert isinstance(res, dict), f"result is not a dict: {res}"
+            if "success" in res and res["success"] is False:
+                error_count += 1
+                if "error" in res:
+                    print(f"Error in result: {res['error']}")
+            else:
+                success_count += 1
+                assert "data" in res, f"No 'data' in result: {res}"
+                data = res["data"]
+                assert isinstance(data, dict), f"data is not a dict: {data}"
+                assert "embeddings" in data, f"No 'embeddings' in data: {data}"
+                assert isinstance(data["embeddings"], list), f"'embeddings' is not a list: {data}"
+    
+    # Calculate statistics
+    total_time = end_time - start_time
+    texts_per_second = total_texts / total_time
+    
+    print(f"\nError Handling Under Load Test Results:")
+    print(f"Total texts processed: {total_texts}")
+    print(f"Successful batches: {success_count}")
+    print(f"Failed batches: {error_count}")
+    print(f"Exception batches: {exception_count}")
+    print(f"Total time: {total_time:.2f} seconds")
+    print(f"Processing speed: {texts_per_second:.2f} texts/second")
+    
+    # Assertions
+    assert success_count > 0, "No successful batches processed"
+    assert error_count > 0, "No errors detected with invalid inputs"
+    assert total_time > 0, "Invalid processing time"
+    # Allow some exceptions under stress
+    assert exception_count < total_texts * 0.05, "Too many exceptions" 

embed_client-0.0.1/embed_client/example_async_usage.py

@@ -1,94 +0,0 @@
-"""
-Example usage of EmbeddingServiceAsyncClient.
-
-This example demonstrates how to use the async client to check the health of the embedding service,
-request embeddings, and handle all possible exceptions.
-
-Run this script with:
-    python -m asyncio embed_client/example_async_usage.py --base-url http://localhost --port 8001
-
-You can also set EMBED_CLIENT_BASE_URL and EMBED_CLIENT_PORT environment variables.
-"""
-
-import asyncio
-import sys
-import os
-from embed_client.async_client import (
-    EmbeddingServiceAsyncClient,
-    EmbeddingServiceConnectionError,
-    EmbeddingServiceHTTPError,
-    EmbeddingServiceAPIError,
-    EmbeddingServiceError,
-)
-
-def get_params():
-    base_url = None
-    port = None
-    for i, arg in enumerate(sys.argv):
-        if arg in ("--base-url", "-b") and i + 1 < len(sys.argv):
-            base_url = sys.argv[i + 1]
-        if arg in ("--port", "-p") and i + 1 < len(sys.argv):
-            port = sys.argv[i + 1]
-    if not base_url:
-        base_url = os.environ.get("EMBED_CLIENT_BASE_URL")
-    if not port:
-        port = os.environ.get("EMBED_CLIENT_PORT")
-    if not base_url or not port:
-        print("Error: base_url and port must be provided via --base-url/--port arguments or EMBED_CLIENT_BASE_URL/EMBED_CLIENT_PORT environment variables.")
-        sys.exit(1)
-        return None, None
-    return base_url, int(port)
-
-async def main():
-    base_url, port = get_params()
-    # Always use try/except to handle all possible errors
-    try:
-        async with EmbeddingServiceAsyncClient(base_url=base_url, port=port) as client:
-            # Check health
-            try:
-                health = await client.health()
-                print("Service health:", health)
-            except EmbeddingServiceConnectionError as e:
-                print("[Connection error]", e)
-                return
-            except EmbeddingServiceHTTPError as e:
-                print(f"[HTTP error] {e.status}: {e.message}")
-                return
-            except EmbeddingServiceError as e:
-                print("[Other error]", e)
-                return
-
-            # Request embeddings for a list of texts
-            texts = ["hello world", "test embedding"]
-            try:
-                result = await client.cmd("embed", params={"texts": texts})
-                vectors = result["result"]
-                print(f"Embeddings for {len(texts)} texts:")
-                for i, vec in enumerate(vectors):
-                    print(f"  Text: {texts[i]!r}\n  Vector: {vec[:5]}... (total {len(vec)} dims)")
-            except EmbeddingServiceAPIError as e:
-                print("[API error]", e.error)
-            except EmbeddingServiceHTTPError as e:
-                print(f"[HTTP error] {e.status}: {e.message}")
-            except EmbeddingServiceConnectionError as e:
-                print("[Connection error]", e)
-            except EmbeddingServiceError as e:
-                print("[Other error]", e)
-
-            # Example: error handling for invalid command
-            try:
-                await client.cmd("not_a_command")
-            except EmbeddingServiceAPIError as e:
-                print("[API error for invalid command]", e.error)
-
-            # Example: error handling for empty texts
-            try:
-                await client.cmd("embed", params={"texts": []})
-            except EmbeddingServiceAPIError as e:
-                print("[API error for empty texts]", e.error)
-
-    except Exception as e:
-        print("[Unexpected error]", e)
-
-if __name__ == "__main__":
-    asyncio.run(main())