embed-client 0.0.1__tar.gz

embed_client-0.0.1/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: embed-client
+Version: 0.0.1
+Summary: Async client for Embedding Service API
+Author: Your Name
+Requires-Dist: aiohttp
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

embed_client-0.0.1/README.md

@@ -0,0 +1 @@
+# vvz-embed-client

embed_client-0.0.1/embed_client/__init__.py

@@ -0,0 +1 @@
+ 

embed_client-0.0.1/embed_client/async_client.py

@@ -0,0 +1,180 @@
+"""
+Async client for Embedding Service API (OpenAPI 3.0.2)
+
+- 100% type-annotated
+- English docstrings and examples
+- Ready for PyPi
+"""
+
+from typing import Any, Dict, List, Optional, Union
+import aiohttp
+
+class EmbeddingServiceError(Exception):
+    """Base exception for EmbeddingServiceAsyncClient."""
+
+class EmbeddingServiceConnectionError(EmbeddingServiceError):
+    """Raised when the service is unavailable or connection fails."""
+
+class EmbeddingServiceHTTPError(EmbeddingServiceError):
+    """Raised for HTTP errors (4xx, 5xx)."""
+    def __init__(self, status: int, message: str):
+        super().__init__(f"HTTP {status}: {message}")
+        self.status = status
+        self.message = message
+
+class EmbeddingServiceAPIError(EmbeddingServiceError):
+    """Raised for errors returned by the API in the response body."""
+    def __init__(self, error: Any):
+        super().__init__(f"API error: {error}")
+        self.error = error
+
+class EmbeddingServiceAsyncClient:
+    """
+    Asynchronous client for the Embedding Service API.
+    Args:
+        base_url (str): Base URL of the embedding service (e.g., "http://localhost").
+        port (int): Port of the embedding service (e.g., 8001).
+    Raises:
+        ValueError: If base_url or port is not provided.
+    """
+    def __init__(self, base_url: str, port: int):
+        if not base_url:
+            raise ValueError("base_url must be provided.")
+        if 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:
+        url = (base_url or self.base_url).rstrip("/")
+        port_val = port if port is not None else self.port
+        return f"{url}:{port_val}{path}"
+
+    async def __aenter__(self):
+        self._session = aiohttp.ClientSession()
+        return self
+
+    async def __aexit__(self, exc_type, exc, tb):
+        if self._session:
+            await self._session.close()
+            self._session = None
+
+    async def health(self, base_url: Optional[str] = None, port: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Check the health of the service.
+        Args:
+            base_url (str, optional): Override base URL.
+            port (int, optional): Override port.
+        Returns:
+            dict: Health status and model info.
+        """
+        url = self._make_url("/health", base_url, port)
+        try:
+            async with self._session.get(url) as resp:
+                await self._raise_for_status(resp)
+                return await resp.json()
+        except EmbeddingServiceHTTPError:
+            raise
+        except EmbeddingServiceConnectionError:
+            raise
+        except aiohttp.ClientConnectionError as e:
+            raise EmbeddingServiceConnectionError(f"Connection error: {e}") from e
+        except aiohttp.ClientResponseError as e:
+            raise EmbeddingServiceHTTPError(e.status, e.message) from e
+        except Exception as e:
+            raise EmbeddingServiceError(f"Unexpected error: {e}") from e
+
+    async def get_openapi_schema(self, base_url: Optional[str] = None, port: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Get the OpenAPI schema of the service.
+        Args:
+            base_url (str, optional): Override base URL.
+            port (int, optional): Override port.
+        Returns:
+            dict: OpenAPI schema.
+        """
+        url = self._make_url("/openapi.json", base_url, port)
+        try:
+            async with self._session.get(url) as resp:
+                await self._raise_for_status(resp)
+                return await resp.json()
+        except EmbeddingServiceHTTPError:
+            raise
+        except EmbeddingServiceConnectionError:
+            raise
+        except aiohttp.ClientConnectionError as e:
+            raise EmbeddingServiceConnectionError(f"Connection error: {e}") from e
+        except aiohttp.ClientResponseError as e:
+            raise EmbeddingServiceHTTPError(e.status, e.message) from e
+        except Exception as e:
+            raise EmbeddingServiceError(f"Unexpected error: {e}") from e
+
+    async def get_commands(self, base_url: Optional[str] = None, port: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Get the list of available commands.
+        Args:
+            base_url (str, optional): Override base URL.
+            port (int, optional): Override port.
+        Returns:
+            dict: List of commands and their descriptions.
+        """
+        url = self._make_url("/api/commands", base_url, port)
+        try:
+            async with self._session.get(url) as resp:
+                await self._raise_for_status(resp)
+                return await resp.json()
+        except EmbeddingServiceHTTPError:
+            raise
+        except EmbeddingServiceConnectionError:
+            raise
+        except aiohttp.ClientConnectionError as e:
+            raise EmbeddingServiceConnectionError(f"Connection error: {e}") from e
+        except aiohttp.ClientResponseError as e:
+            raise EmbeddingServiceHTTPError(e.status, e.message) from e
+        except Exception as e:
+            raise EmbeddingServiceError(f"Unexpected error: {e}") from e
+
+    async def cmd(self, command: str, params: Optional[Dict[str, Any]] = None, base_url: Optional[str] = None, port: Optional[int] = None) -> Dict[str, Any]:
+        """
+        Execute a command via JSON-RPC protocol.
+        Args:
+            command (str): Command to execute (embed, models, health, help, config).
+            params (dict, optional): Parameters for the command.
+            base_url (str, optional): Override base URL.
+            port (int, optional): Override port.
+        Returns:
+            dict: Command execution result.
+        """
+        url = self._make_url("/cmd", base_url, port)
+        payload = {"command": command}
+        if params is not None:
+            payload["params"] = params
+        try:
+            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"])
+                return data
+        except EmbeddingServiceAPIError:
+            raise
+        except EmbeddingServiceHTTPError:
+            raise
+        except EmbeddingServiceConnectionError:
+            raise
+        except aiohttp.ClientConnectionError as e:
+            raise EmbeddingServiceConnectionError(f"Connection error: {e}") from e
+        except aiohttp.ClientResponseError as e:
+            raise EmbeddingServiceHTTPError(e.status, e.message) from e
+        except Exception as e:
+            raise EmbeddingServiceError(f"Unexpected error: {e}") from e
+
+    async def _raise_for_status(self, resp: aiohttp.ClientResponse):
+        try:
+            resp.raise_for_status()
+        except aiohttp.ClientResponseError as e:
+            raise EmbeddingServiceHTTPError(e.status, e.message) from e
+
+    # TODO: Add methods for /cmd, /api/commands, etc. 

embed_client-0.0.1/embed_client/example_async_usage.py

@@ -0,0 +1,94 @@
+"""
+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()) 

embed_client-0.0.1/embed_client/example_async_usage_ru.py

@@ -0,0 +1,94 @@
+"""
+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_ru.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()) 

embed_client-0.0.1/embed_client.egg-info/PKG-INFO

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: embed-client
+Version: 0.0.1
+Summary: Async client for Embedding Service API
+Author: Your Name
+Requires-Dist: aiohttp
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-asyncio; extra == "test"

embed_client-0.0.1/embed_client.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+embed_client/__init__.py
+embed_client/async_client.py
+embed_client/example_async_usage.py
+embed_client/example_async_usage_ru.py
+embed_client.egg-info/PKG-INFO
+embed_client.egg-info/SOURCES.txt
+embed_client.egg-info/dependency_links.txt
+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_example_async_usage.py
+tests/test_example_async_usage_ru.py

embed_client-0.0.1/embed_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

embed_client-0.0.1/embed_client.egg-info/requires.txt

@@ -0,0 +1,5 @@
+aiohttp
+
+[test]
+pytest
+pytest-asyncio

embed_client-0.0.1/embed_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+embed_client

embed_client-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "embed-client"
+version = "0.0.1"
+description = "Async client for Embedding Service API"
+authors = [{name = "Your Name"}]
+dependencies = [
+    "aiohttp",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest",
+    "pytest-asyncio",
+]
+
+[tool.pytest.ini_options]
+asyncio_default_fixture_loop_scope = "function" 

embed_client-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

embed_client-0.0.1/tests/test_async_client.py

@@ -0,0 +1,241 @@
+import pytest
+import pytest_asyncio
+from unittest.mock import patch, MagicMock
+from embed_client.async_client import EmbeddingServiceAsyncClient, EmbeddingServiceAPIError, EmbeddingServiceHTTPError, EmbeddingServiceError, EmbeddingServiceConnectionError
+
+BASE_URL = "http://testserver"
+PORT = 1234
+
+class MockAiohttpResponse:
+    def __init__(self, json_data=None, status=200, raise_http=None, text_data=None):
+        self._json = json_data
+        self._status = status
+        self._raise_http = raise_http
+        self._text = text_data
+    async def __aenter__(self):
+        return self
+    async def __aexit__(self, exc_type, exc, tb):
+        return None
+    async def json(self):
+        if self._json is not None:
+            return self._json
+        raise ValueError("No JSON")
+    async def text(self):
+        return self._text or ""
+    def raise_for_status(self):
+        if self._raise_http:
+            raise self._raise_http
+        return None
+    @property
+    def status(self):
+        return self._status
+
+@pytest_asyncio.fixture
+async def client():
+    async with EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT) as c:
+        yield c
+
+def make_url(path):
+    return f"{BASE_URL}:{PORT}{path}"
+
+@pytest.mark.asyncio
+async def test_health(client):
+    with patch.object(client._session, 'get', return_value=MockAiohttpResponse({"status": "ok"})) as mock_get:
+        result = await client.health()
+        assert result == {"status": "ok"}
+        mock_get.assert_called_with(make_url("/health"))
+
+@pytest.mark.asyncio
+async def test_get_openapi_schema(client):
+    with patch.object(client._session, 'get', return_value=MockAiohttpResponse({"openapi": "3.0.2"})) as mock_get:
+        result = await client.get_openapi_schema()
+        assert result == {"openapi": "3.0.2"}
+        mock_get.assert_called_with(make_url("/openapi.json"))
+
+@pytest.mark.asyncio
+async def test_get_commands(client):
+    with patch.object(client._session, 'get', return_value=MockAiohttpResponse({"commands": ["embed", "models"]})) as mock_get:
+        result = await client.get_commands()
+        assert result == {"commands": ["embed", "models"]}
+        mock_get.assert_called_with(make_url("/api/commands"))
+
+@pytest.mark.asyncio
+async def test_cmd(client):
+    with patch.object(client._session, 'post', return_value=MockAiohttpResponse({"result": "ok"})) as mock_post:
+        result = await client.cmd("embed", params={"texts": ["abc"]})
+        assert result == {"result": "ok"}
+        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)
+
+# Некорректные параметры: не-строка в 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):
+            await client.cmd("embed", params={"texts": [123, "ok"]})
+
+# Некорректные параметры: невалидный params
+@pytest.mark.asyncio
+async def test_embed_invalid_params_type(client):
+    with patch.object(client._session, 'post', return_value=MockAiohttpResponse({"error": {"code": 422, "message": "Invalid params"}})) as mock_post:
+        with pytest.raises(EmbeddingServiceAPIError):
+            await client.cmd("embed", params="not_a_dict")
+
+# Не-JSON ответ
+@pytest.mark.asyncio
+async def test_non_json_response(client):
+    class BadResponse(MockAiohttpResponse):
+        async def json(self):
+            raise ValueError("Not a JSON")
+    with patch.object(client._session, 'post', return_value=BadResponse(text_data="<html>error</html>")) as mock_post:
+        with pytest.raises(EmbeddingServiceError):
+            await client.cmd("embed", params={"texts": ["abc"]})
+
+# 500 ошибка сервера
+@pytest.mark.asyncio
+async def test_server_500_error(client):
+    from aiohttp import ClientResponseError
+    err = ClientResponseError(request_info=None, history=None, status=500, message="Internal Server Error")
+    with patch.object(client._session, 'post', return_value=MockAiohttpResponse(raise_http=err, status=500)) as mock_post:
+        with pytest.raises(EmbeddingServiceHTTPError):
+            await client.cmd("embed", params={"texts": ["abc"]})
+
+# embed без params
+@pytest.mark.asyncio
+async def test_embed_no_params(client):
+    with patch.object(client._session, 'post', return_value=MockAiohttpResponse({"error": {"code": 422, "message": "Missing params"}})) as mock_post:
+        with pytest.raises(EmbeddingServiceAPIError):
+            await client.cmd("embed")
+
+# Вектор не той размерности (например, сервер вернул 2D массив, а ожидали 3D)
+@pytest.mark.asyncio
+async def test_embed_wrong_vector_shape(client):
+    # Ожидаем список списков, но сервер вернул список
+    with patch.object(client._session, 'post', return_value=MockAiohttpResponse({"embeddings": [1.0, 2.0, 3.0]})) as mock_post:
+        result = await client.cmd("embed", params={"texts": ["abc"]})
+        vectors = result["embeddings"]
+        assert isinstance(vectors, list)
+        # Проверяем, что каждый элемент — список (будет False, тест покажет ошибку)
+        assert all(isinstance(vec, list) for vec in vectors) is False
+
+# Покрытие: except EmbeddingServiceHTTPError
+@pytest.mark.asyncio
+async def test_health_http_error(client):
+    with patch.object(client._session, 'get', side_effect=EmbeddingServiceHTTPError(500, "fail")):
+        with pytest.raises(EmbeddingServiceHTTPError):
+            await client.health()
+
+# Покрытие: except EmbeddingServiceConnectionError
+@pytest.mark.asyncio
+async def test_health_connection_error(client):
+    with patch.object(client._session, 'get', side_effect=EmbeddingServiceConnectionError("fail")):
+        with pytest.raises(EmbeddingServiceConnectionError):
+            await client.health()
+
+# Покрытие: except Exception (ValueError)
+@pytest.mark.asyncio
+async def test_health_unexpected_error(client):
+    with patch.object(client._session, 'get', side_effect=ValueError("fail")):
+        with pytest.raises(EmbeddingServiceError):
+            await client.health()
+
+# Аналогично для get_openapi_schema
+@pytest.mark.asyncio
+async def test_get_openapi_schema_http_error(client):
+    with patch.object(client._session, 'get', side_effect=EmbeddingServiceHTTPError(500, "fail")):
+        with pytest.raises(EmbeddingServiceHTTPError):
+            await client.get_openapi_schema()
+
+@pytest.mark.asyncio
+async def test_get_openapi_schema_connection_error(client):
+    with patch.object(client._session, 'get', side_effect=EmbeddingServiceConnectionError("fail")):
+        with pytest.raises(EmbeddingServiceConnectionError):
+            await client.get_openapi_schema()
+
+@pytest.mark.asyncio
+async def test_get_openapi_schema_unexpected_error(client):
+    with patch.object(client._session, 'get', side_effect=ValueError("fail")):
+        with pytest.raises(EmbeddingServiceError):
+            await client.get_openapi_schema()
+
+# Аналогично для get_commands
+@pytest.mark.asyncio
+async def test_get_commands_http_error(client):
+    with patch.object(client._session, 'get', side_effect=EmbeddingServiceHTTPError(500, "fail")):
+        with pytest.raises(EmbeddingServiceHTTPError):
+            await client.get_commands()
+
+@pytest.mark.asyncio
+async def test_get_commands_connection_error(client):
+    with patch.object(client._session, 'get', side_effect=EmbeddingServiceConnectionError("fail")):
+        with pytest.raises(EmbeddingServiceConnectionError):
+            await client.get_commands()
+
+@pytest.mark.asyncio
+async def test_get_commands_unexpected_error(client):
+    with patch.object(client._session, 'get', side_effect=ValueError("fail")):
+        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():
+    from aiohttp import ClientResponseError
+    client = EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT)
+    resp = MagicMock()
+    resp.raise_for_status.side_effect = ClientResponseError(request_info=None, history=None, status=400, message="fail")
+    with pytest.raises(EmbeddingServiceHTTPError):
+        await client._raise_for_status(resp)
+
+# Покрытие: _raise_for_status - не ClientResponseError
+@pytest.mark.asyncio
+async def test_raise_for_status_other_error():
+    client = EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT)
+    resp = MagicMock()
+    resp.raise_for_status.side_effect = ValueError("fail")
+    with pytest.raises(ValueError):
+        await client._raise_for_status(resp)
+
+# Покрытие: __aenter__ и __aexit__ - ошибка при создании/закрытии сессии
+@pytest.mark.asyncio
+async def test_aenter_aexit_exceptions():
+    client = EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT)
+    # Исключение при создании сессии
+    orig = client._session
+    client._session = None
+    with patch("aiohttp.ClientSession", side_effect=RuntimeError("fail")):
+        with pytest.raises(RuntimeError):
+            async with client:
+                pass
+    # Исключение при закрытии сессии
+    class BadSession:
+        async def close(self):
+            raise RuntimeError("fail")
+    client._session = BadSession()
+    with pytest.raises(RuntimeError):
+        await client.__aexit__(None, None, None) 

embed_client-0.0.1/tests/test_async_client_real.py

@@ -0,0 +1,110 @@
+import pytest
+import pytest_asyncio
+from embed_client.async_client import EmbeddingServiceAsyncClient, EmbeddingServiceAPIError, EmbeddingServiceHTTPError
+
+BASE_URL = "http://localhost"
+PORT = 8001
+
+async def is_service_available():
+    try:
+        async with EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT) as client:
+            await client.health()
+        return True
+    except Exception:
+        return False
+
+@pytest_asyncio.fixture
+async def real_client():
+    async with EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT) as client:
+        yield client
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_health(real_client):
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    result = await real_client.health()
+    assert "status" in result
+    assert result["status"] in ("ok", "error")
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_openapi(real_client):
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    result = await real_client.get_openapi_schema()
+    assert "openapi" in result
+    assert result["openapi"].startswith("3.")
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_get_commands(real_client):
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    result = await real_client.get_commands()
+    assert isinstance(result, dict)
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_cmd_help(real_client):
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    result = await real_client.cmd("help")
+    assert isinstance(result, dict)
+
+def extract_vectors(result):
+    if "embeddings" in result:
+        return result["embeddings"]
+    elif "result" in result:
+        if isinstance(result["result"], list):
+            return result["result"]
+        elif isinstance(result["result"], dict) and "embeddings" in result["result"]:
+            return result["result"]["embeddings"]
+        else:
+            pytest.fail("No embeddings in result['result']")
+    else:
+        pytest.fail("No embeddings or result in response")
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_embed_vector(real_client):
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    texts = ["hello world", "test embedding"]
+    params = {"texts": texts}
+    result = await real_client.cmd("embed", params=params)
+    vectors = extract_vectors(result)
+    assert isinstance(vectors, list)
+    assert len(vectors) == len(texts)
+    assert all(isinstance(vec, list) for vec in vectors)
+    assert all(isinstance(x, (float, int)) for vec in vectors for x in vec)
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+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
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_cmd_invalid_command(real_client):
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    with pytest.raises(EmbeddingServiceAPIError):
+        await real_client.cmd("not_a_command")
+
+@pytest.mark.asyncio
+@pytest.mark.integration
+async def test_real_invalid_endpoint():
+    if not await is_service_available():
+        pytest.skip("Real service on localhost:8001 is not available.")
+    async with EmbeddingServiceAsyncClient(base_url=BASE_URL, port=PORT) as client:
+        with pytest.raises(EmbeddingServiceHTTPError):
+            # Пробуем обратиться к несуществующему endpoint
+            url = f"{BASE_URL}:{PORT}/notfound"
+            async with client._session.get(url) as resp:
+                await client._raise_for_status(resp) 

embed_client-0.0.1/tests/test_example_async_usage.py

@@ -0,0 +1,29 @@
+import sys
+import types
+import pytest
+import asyncio
+from unittest.mock import patch, AsyncMock
+
+@pytest.mark.asyncio
+async def test_example_async_usage(monkeypatch):
+    # Подменяем sys.argv для передачи base_url и порта
+    monkeypatch.setattr(sys, 'argv', ['example_async_usage.py', '--base-url', 'http://test', '--port', '8001'])
+    # Мокаем EmbeddingServiceAsyncClient и его методы
+    with patch('embed_client.example_async_usage.EmbeddingServiceAsyncClient.__aenter__', new=AsyncMock(return_value=AsyncMock())), \
+         patch('embed_client.example_async_usage.EmbeddingServiceAsyncClient.health', new=AsyncMock(return_value={"status": "ok"})):
+        # Импортируем как модуль, чтобы выполнить main()
+        import importlib
+        import embed_client.example_async_usage as example
+        importlib.reload(example)
+        await example.main()
+
+@pytest.mark.asyncio
+async def test_example_async_usage_no_base_url(monkeypatch):
+    monkeypatch.setattr(sys, 'argv', ['example_async_usage.py'])
+    with patch('builtins.print') as mock_print, patch('sys.exit') as mock_exit:
+        import importlib
+        import embed_client.example_async_usage as example
+        importlib.reload(example)
+        await example.main()
+        mock_print.assert_called()
+        mock_exit.assert_called() 

embed_client-0.0.1/tests/test_example_async_usage_ru.py

@@ -0,0 +1,25 @@
+import sys
+import pytest
+import asyncio
+from unittest.mock import patch, AsyncMock
+
+@pytest.mark.asyncio
+async def test_example_async_usage_ru(monkeypatch):
+    monkeypatch.setattr(sys, 'argv', ['example_async_usage_ru.py', '--base-url', 'http://test', '--port', '8001'])
+    with patch('embed_client.example_async_usage_ru.EmbeddingServiceAsyncClient.__aenter__', new=AsyncMock(return_value=AsyncMock())), \
+         patch('embed_client.example_async_usage_ru.EmbeddingServiceAsyncClient.health', new=AsyncMock(return_value={"status": "ok"})):
+        import importlib
+        import embed_client.example_async_usage_ru as example
+        importlib.reload(example)
+        await example.main()
+
+@pytest.mark.asyncio
+async def test_example_async_usage_ru_no_base_url(monkeypatch):
+    monkeypatch.setattr(sys, 'argv', ['example_async_usage_ru.py'])
+    with patch('builtins.print') as mock_print, patch('sys.exit') as mock_exit:
+        import importlib
+        import embed_client.example_async_usage_ru as example
+        importlib.reload(example)
+        await example.main()
+        mock_print.assert_called()
+        mock_exit.assert_called()