svo-client 0.1.0__tar.gz

svo_client-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: svo-client
+Version: 0.1.0
+Summary: Async client for SVO semantic chunker microservice.
+Home-page: https://github.com/your_org/svo_client
+Author: Your Name
+Author-email: your@email.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: chunk_metadata_adapter
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

svo_client-0.1.0/README.md

@@ -0,0 +1,27 @@
+# svo-client
+
+Асинхронный Python-клиент для SVO Semantic Chunker microservice.
+
+## Установка
+
+```bash
+pip install svo-client
+```
+
+## Пример использования
+
+```python
+from svo_client.chunker_client import ChunkerClient
+import asyncio
+
+async def main():
+    async with ChunkerClient() as client:
+        chunks = await client.chunk_text("Your text here.")
+        print(client.reconstruct_text(chunks))
+
+asyncio.run(main())
+```
+
+## Документация
+- [OpenAPI schema](docs/openapi.json)
+- [Примеры и тесты](tests/test_chunker_client.py)

svo_client-0.1.0/setup.cfg

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

svo_client-0.1.0/setup.py

@@ -0,0 +1,23 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="svo-client",
+    version="0.1.0",
+    description="Async client for SVO semantic chunker microservice.",
+    author="Your Name",
+    author_email="your@email.com",
+    packages=find_packages("."),
+    install_requires=[
+        "aiohttp>=3.8.0",
+        "pydantic>=2.0.0",
+        "chunk_metadata_adapter"
+    ],
+    python_requires=">=3.8",
+    url="https://github.com/your_org/svo_client",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    include_package_data=True,
+) 

svo_client-0.1.0/svo_client/__init__.py

@@ -0,0 +1 @@
+ 

svo_client-0.1.0/svo_client/chunker_client.py

@@ -0,0 +1,143 @@
+"""Async client for SVO semantic chunker microservice."""
+
+__version__ = "0.1.0"
+
+import aiohttp
+from typing import List, Optional, Any, Dict
+from chunk_metadata_adapter import SemanticChunk
+from pydantic import BaseModel
+
+class Token(BaseModel):
+    text: str
+    lemma: Optional[str] = None
+    pos: Optional[str] = None
+    head: Optional[int] = None
+    deprel: Optional[str] = None
+    id: Optional[int] = None
+    sent_id: Optional[str] = None
+
+class SV(BaseModel):
+    subject: Optional[Token] = None
+    verb: Optional[Token] = None
+
+class ChunkFull(BaseModel):
+    uuid: str
+    source_id: Optional[str] = None
+    ordinal: Optional[int] = None
+    sha256: str
+    text: str
+    summary: Optional[str] = None
+    language: Optional[str] = None
+    type: Optional[str] = None
+    source_path: Optional[str] = None
+    source_lines_start: Optional[int] = None
+    source_lines_end: Optional[int] = None
+    project: Optional[str] = None
+    task_id: Optional[str] = None
+    subtask_id: Optional[str] = None
+    status: Optional[str] = None
+    unit_id: Optional[str] = None
+    created_at: Optional[str] = None
+    tags: Optional[Any] = None
+    role: Optional[str] = None
+    link_parent: Optional[str] = None
+    link_related: Optional[str] = None
+    quality_score: Optional[float] = None
+    coverage: Optional[float] = None
+    cohesion: Optional[float] = None
+    boundary_prev: Optional[float] = None
+    boundary_next: Optional[float] = None
+    used_in_generation: Optional[bool] = None
+    feedback_accepted: Optional[int] = None
+    feedback_rejected: Optional[int] = None
+    start: Optional[int] = None
+    end: Optional[int] = None
+    sv: Optional[SV] = None
+    score: Optional[float] = None
+    embedding: Optional[List[float]] = None
+    tokens: Optional[List[Token]] = None
+    block: Optional[List[Token]] = None
+
+class ChunkerClient:
+    def __init__(self, url: str = "http://localhost", port: int = 8009):
+        self.base_url = f"{url.rstrip('/')}: {port}"
+        self.session: Optional[aiohttp.ClientSession] = None
+
+    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()
+
+    async def get_openapi_schema(self) -> Any:
+        url = f"{self.base_url}/openapi.json"
+        async with self.session.get(url) as resp:
+            resp.raise_for_status()
+            return await resp.json()
+
+    def parse_chunk(self, chunk: Dict[str, Any]) -> ChunkFull:
+        tokens = [Token(**t) for t in chunk.get("tokens", [])] if chunk.get("tokens") else None
+        block = [Token(**t) for t in chunk.get("block", [])] if chunk.get("block") else None
+        sv = None
+        if chunk.get("sv"):
+            sv = SV(**{
+                k: Token(**v) if v else None
+                for k, v in chunk["sv"].items()
+            })
+        return ChunkFull(
+            **{k: v for k, v in chunk.items() if k not in ("tokens", "block", "sv")},
+            tokens=tokens,
+            block=block,
+            sv=sv
+        )
+
+    async def chunk_text(self, text: str, **params) -> List[ChunkFull]:
+        url = f"{self.base_url}/cmd"
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "chunk",
+            "params": {"text": text, **params},
+            "id": 1
+        }
+        async with self.session.post(url, json=payload) as resp:
+            resp.raise_for_status()
+            data = await resp.json()
+            chunks = data.get("result", {}).get("chunks", [])
+            return [self.parse_chunk(chunk) for chunk in chunks]
+
+    async def get_help(self, cmdname: Optional[str] = None) -> Any:
+        url = f"{self.base_url}/cmd"
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "help",
+            "id": 1
+        }
+        if cmdname:
+            payload["params"] = {"cmdname": cmdname}
+        async with self.session.post(url, json=payload) as resp:
+            resp.raise_for_status()
+            return await resp.json()
+
+    async def health(self) -> Any:
+        url = f"{self.base_url}/cmd"
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "health",
+            "id": 1
+        }
+        async with self.session.post(url, json=payload) as resp:
+            resp.raise_for_status()
+            return await resp.json()
+
+    def reconstruct_text(self, chunks: List[ChunkFull]) -> str:
+        """
+        Reconstruct the original text from a list of ChunkFull objects.
+        Склеивает текст из чанков в исходном порядке.
+        """
+        sorted_chunks = sorted(
+            chunks,
+            key=lambda c: c.ordinal if c.ordinal is not None else chunks.index(c)
+        )
+        return ''.join(chunk.text for chunk in sorted_chunks if chunk.text) 

svo_client-0.1.0/svo_client.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: svo-client
+Version: 0.1.0
+Summary: Async client for SVO semantic chunker microservice.
+Home-page: https://github.com/your_org/svo_client
+Author: Your Name
+Author-email: your@email.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Requires-Dist: aiohttp>=3.8.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: chunk_metadata_adapter
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

svo_client-0.1.0/svo_client.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+setup.py
+svo_client/__init__.py
+svo_client/chunker_client.py
+svo_client.egg-info/PKG-INFO
+svo_client.egg-info/SOURCES.txt
+svo_client.egg-info/dependency_links.txt
+svo_client.egg-info/requires.txt
+svo_client.egg-info/top_level.txt
+tests/test_chunker_client.py
+tests/test_examples.py

svo_client-0.1.0/svo_client.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

svo_client-0.1.0/svo_client.egg-info/requires.txt

@@ -0,0 +1,3 @@
+aiohttp>=3.8.0
+pydantic>=2.0.0
+chunk_metadata_adapter

svo_client-0.1.0/svo_client.egg-info/top_level.txt

@@ -0,0 +1 @@
+svo_client

svo_client-0.1.0/tests/test_chunker_client.py

@@ -0,0 +1,119 @@
+import pytest
+import asyncio
+from svo_client.chunker_client import ChunkerClient, ChunkFull, Token, SV
+from typing import List
+import aiohttp
+import sys
+import types
+
+@pytest.mark.asyncio
+async def test_chunk_text_and_reconstruct(monkeypatch):
+    # Мокаем ответ сервера
+    fake_chunks = [
+        {
+            "uuid": "1", "text": "Hello, ", "ordinal": 0, "sha256": "x", "embedding": [1.0],
+            "tokens": [{"text": "Hello"}], "block": [{"text": "Hello"}], "sv": {"subject": {"text": "Hello"}, "verb": {"text": "is"}}
+        },
+        {
+            "uuid": "2", "text": "world!", "ordinal": 1, "sha256": "y", "embedding": [2.0],
+            "tokens": [{"text": "world"}], "block": [{"text": "world"}], "sv": {"subject": {"text": "world"}, "verb": {"text": "exists"}}
+        }
+    ]
+    class FakeResponse:
+        def __init__(self, data): self._data = data
+        async def json(self): return {"result": {"chunks": self._data}}
+        def raise_for_status(self): pass
+    class FakeSession:
+        def __init__(self): self.last_url = None; self.last_json = None
+        def post(self, url, json):
+            class _Ctx:
+                async def __aenter__(self_): return FakeResponse(fake_chunks)
+                async def __aexit__(self_, exc_type, exc, tb): pass
+            self.last_url = url; self.last_json = json
+            return _Ctx()
+        def get(self, url):
+            class _Ctx:
+                async def __aenter__(self_): return FakeResponse({"openapi": "3.0.2"})
+                async def __aexit__(self_, exc_type, exc, tb): pass
+            return _Ctx()
+        async def close(self): pass
+    client = ChunkerClient()
+    client.session = FakeSession()
+    # chunk_text
+    chunks = await client.chunk_text("Hello, world!")
+    assert isinstance(chunks, list)
+    assert all(isinstance(c, ChunkFull) for c in chunks)
+    assert chunks[0].text == "Hello, "
+    assert chunks[1].text == "world!"
+    # reconstruct_text
+    text = client.reconstruct_text(chunks)
+    assert text == "Hello, world!"
+    # Проверка вложенных структур
+    assert isinstance(chunks[0].tokens[0], Token)
+    assert isinstance(chunks[0].sv, SV)
+    assert chunks[0].sv.subject.text == "Hello"
+    assert chunks[1].sv.verb.text == "exists"
+
+@pytest.mark.asyncio
+async def test_get_openapi_schema(monkeypatch):
+    class FakeResponse:
+        async def json(self): return {"openapi": "3.0.2"}
+        def raise_for_status(self): pass
+    class FakeSession:
+        def get(self, url):
+            class _Ctx:
+                async def __aenter__(self_): return FakeResponse()
+                async def __aexit__(self_, exc_type, exc, tb): pass
+            return _Ctx()
+        async def close(self): pass
+    client = ChunkerClient()
+    client.session = FakeSession()
+    schema = await client.get_openapi_schema()
+    assert schema["openapi"] == "3.0.2"
+
+@pytest.mark.asyncio
+async def test_get_help(monkeypatch):
+    class FakeResponse:
+        async def json(self): return {"result": {"commands": {"chunk": {}}}}
+        def raise_for_status(self): pass
+    class FakeSession:
+        def post(self, url, json):
+            class _Ctx:
+                async def __aenter__(self_): return FakeResponse()
+                async def __aexit__(self_, exc_type, exc, tb): pass
+            return _Ctx()
+        async def close(self): pass
+    client = ChunkerClient()
+    client.session = FakeSession()
+    help_info = await client.get_help()
+    assert "commands" in help_info["result"]
+
+@pytest.mark.asyncio
+async def test_health(monkeypatch):
+    class FakeResponse:
+        async def json(self): return {"result": {"success": True}}
+        def raise_for_status(self): pass
+    class FakeSession:
+        def post(self, url, json):
+            class _Ctx:
+                async def __aenter__(self_): return FakeResponse()
+                async def __aexit__(self_, exc_type, exc, tb): pass
+            return _Ctx()
+        async def close(self): pass
+    client = ChunkerClient()
+    client.session = FakeSession()
+    health = await client.health()
+    assert health["result"]["success"] is True
+
+# Интеграционный тест (если сервер доступен)
+@pytest.mark.asyncio
+async def test_chunk_text_integration():
+    try:
+        async with ChunkerClient() as client:
+            chunks = await client.chunk_text("Integration test.")
+            assert isinstance(chunks, list)
+            assert all(isinstance(c, ChunkFull) for c in chunks)
+            if chunks:
+                assert hasattr(chunks[0], "text")
+    except aiohttp.ClientConnectorError:
+        pytest.skip("Chunker server not available for integration test.") 

svo_client-0.1.0/tests/test_examples.py

@@ -0,0 +1,30 @@
+import pytest
+import asyncio
+from svo_client.chunker_client import ChunkerClient, ChunkFull
+import sys
+import types
+
+@pytest.mark.asyncio
+async def test_example_usage(monkeypatch):
+    # Мокаем методы клиента
+    async def fake_chunk_text(self, text, **params):
+        return [ChunkFull(uuid="1", text="Hello, ", sha256="x", ordinal=0), ChunkFull(uuid="2", text="world!", sha256="y", ordinal=1)]
+    async def fake_health(self):
+        return {"status": "ok"}
+    async def fake_get_help(self, cmdname=None):
+        return {"help": "info"}
+    # Подмена методов
+    monkeypatch.setattr(ChunkerClient, "chunk_text", fake_chunk_text)
+    monkeypatch.setattr(ChunkerClient, "health", fake_health)
+    monkeypatch.setattr(ChunkerClient, "get_help", fake_get_help)
+
+    async with ChunkerClient() as client:
+        chunks = await client.chunk_text("test")
+        assert isinstance(chunks, list)
+        assert all(isinstance(c, ChunkFull) for c in chunks)
+        text = client.reconstruct_text(chunks)
+        assert text == "Hello, world!"
+        health = await client.health()
+        assert health["status"] == "ok"
+        help_info = await client.get_help()
+        assert help_info["help"] == "info"