svo-client-dev 4.0.21__py3-none-any.whl

svo_client/__init__.py

@@ -0,0 +1,75 @@
+"""
+SVO Chunker client package.
+
+Transport is ``mcp_proxy_adapter`` ``JsonRpcClient`` only. JSON-RPC and file
+transfers use HTTP(S); queued job completion uses WebSocket ``/ws`` as
+implemented by the adapter (including jobs that appear only after the server
+queue takes over from a short synchronous JSON-RPC window; adapter >= 8.10).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from svo_client.chunk_presets import KNOWN_CHUNK_SET_PRESETS
+from svo_client.client import (
+    SvoChunkerClient,
+    build_file_chunk_params,
+    extract_file_chunk_success_payload,
+    parse_chunk_ndjson,
+    parse_chunk_ndjson_file,
+    unwrap_command_result,
+)
+from svo_client.connect_defaults import (
+    chunker_client_kwargs_from_base_url,
+    chunker_client_kwargs_from_chunker_server_config,
+    default_chunker_client_kwargs,
+    resolve_mtls_triplet,
+)
+from svo_client.exceptions import (
+    SvoChunkingError,
+    SvoClientError,
+    SvoConnectionError,
+    SvoTimeoutError,
+    SvoValidationError,
+)
+from svo_client.file_processor import process_file_via_file_chunk
+
+
+def __getattr__(name: str):
+    """Expose the version copied from the server source into release artifacts."""
+
+    if name != "__version__":
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    try:
+        from svo_client._version import __version__ as packaged_version
+
+        return packaged_version
+    except ModuleNotFoundError:
+        # A source checkout has no generated svo_client._version module. Read the
+        # same authoritative file that the release staging step copies.
+        import runpy
+        from pathlib import Path
+
+        version_path = Path(__file__).parents[1] / "svo_chunker" / "_version.py"
+        return runpy.run_path(str(version_path))["__version__"]
+
+__all__ = [
+    "KNOWN_CHUNK_SET_PRESETS",
+    "SvoChunkerClient",
+    "chunker_client_kwargs_from_base_url",
+    "chunker_client_kwargs_from_chunker_server_config",
+    "default_chunker_client_kwargs",
+    "resolve_mtls_triplet",
+    "SvoClientError",
+    "SvoConnectionError",
+    "SvoTimeoutError",
+    "SvoValidationError",
+    "SvoChunkingError",
+    "build_file_chunk_params",
+    "extract_file_chunk_success_payload",
+    "parse_chunk_ndjson",
+    "parse_chunk_ndjson_file",
+    "unwrap_command_result",
+    "process_file_via_file_chunk",
+    "__version__",
+]

svo_client/_version.py

@@ -0,0 +1,3 @@
+"""Package version shared by runtime and packaging metadata."""
+
+__version__ = "4.0.21"

svo_client/aiohttp_ws_max_message.py

@@ -0,0 +1,50 @@
+"""
+aiohttp WebSocket inbound message size for large chunk job results.
+
+``mcp_proxy_adapter`` uses ``aiohttp.ClientSession.ws_connect`` with aiohttp's
+default ``max_msg_size=4 MiB``. Large ``chunk`` / ``file_chunk`` JSON payloads
+delivered over ``/ws`` can exceed that; the reader then fails with
+``Message size … exceeds limit 4194304``.
+
+The Hypercorn server side already allows large WS frames (default
+``websocket_max_message_size`` is 16 MiB). This module aligns the **client**
+default with that cap so ``svo_client`` can receive large terminal job messages.
+
+Call :func:`apply_aiohttp_ws_max_message_patch` once before any WebSocket
+connection from the adapter stack (invoked from ``svo_client.core`` before
+``JsonRpcClient`` import).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import functools
+from typing import Any
+
+# 16 MiB — matches typical Hypercorn ``websocket_max_message_size``; override
+# aiohttp's 4 MiB default for ``/ws`` job completion payloads.
+_SVO_WS_MAX_MESSAGE_BYTES = 16 * 1024 * 1024
+
+_patch_applied = False
+
+
+def apply_aiohttp_ws_max_message_patch() -> None:
+    """Monkeypatch ``ClientSession.ws_connect`` default ``max_msg_size`` to 16 MiB."""
+    global _patch_applied
+    if _patch_applied:
+        return
+    import aiohttp
+
+    _orig = aiohttp.ClientSession.ws_connect
+
+    @functools.wraps(_orig)
+    def _patched_ws_connect(self: Any, *args: Any, **kwargs: Any) -> Any:
+        # ws_connect is synchronous; returns _WSRequestContextManager (not a coroutine).
+        if "max_msg_size" not in kwargs:
+            kwargs["max_msg_size"] = _SVO_WS_MAX_MESSAGE_BYTES
+        return _orig(self, *args, **kwargs)
+
+    aiohttp.ClientSession.ws_connect = _patched_ws_connect
+    _patch_applied = True

svo_client/chunk_presets.py

@@ -0,0 +1,36 @@
+"""
+Stable client-side names for server ``chunk_set`` presets (``config.chunk_sets``).
+
+The server remains authoritative: new presets may appear without a client release.
+``KNOWN_CHUNK_SET_PRESETS`` documents the set shipped with the current server
+contract used in this repo; unknown names are still forwarded on the wire.
+"""
+
+from __future__ import annotations
+
+import logging
+from typing import Final, FrozenSet, Optional
+
+__all__ = ["KNOWN_CHUNK_SET_PRESETS", "warn_if_unknown_chunk_set"]
+
+KNOWN_CHUNK_SET_PRESETS: Final[tuple[str, ...]] = (
+    "plain_text",
+    "technical_text",
+    "docstring",
+    "scientific_text",
+    "fiction",
+    "chat",
+    "log",
+)
+
+_KNOWN: FrozenSet[str] = frozenset(KNOWN_CHUNK_SET_PRESETS)
+
+
+def warn_if_unknown_chunk_set(chunk_set: Optional[str]) -> None:
+    """Log a single warning when *chunk_set* is set but not in ``KNOWN_CHUNK_SET_PRESETS``."""
+    if chunk_set is None or chunk_set in _KNOWN:
+        return
+    logging.getLogger(__name__).warning(
+        "chunk_set %r is not in KNOWN_CHUNK_SET_PRESETS; the server will validate the name",
+        chunk_set,
+    )

svo_client/cli.py

@@ -0,0 +1,225 @@
+"""
+CLI: list / help / run (commands and help from server).
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import argparse
+import asyncio
+import json
+import sys
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+_PROJECT_ROOT = Path(__file__).resolve().parent.parent
+if str(_PROJECT_ROOT) not in sys.path:
+    sys.path.insert(0, str(_PROJECT_ROOT))
+
+from svo_client import SvoChunkerClient  # noqa: E402
+from svo_client.exceptions import (  # noqa: E402
+    SvoChunkingError,
+    SvoConnectionError,
+    SvoTimeoutError,
+    SvoValidationError,
+)
+
+
+def _format_help_for_command(info: Dict[str, Any]) -> str:
+    lines = []
+    desc = info.get("description", "")
+    if desc:
+        lines.append(desc)
+    schema = info.get("schema", {})
+    props = schema.get("properties", {})
+    if props:
+        lines.append("")
+        lines.append("Parameters:")
+        for key, meta in props.items():
+            desc = meta.get("description", "")
+            typ = meta.get("type", "string")
+            lines.append(f"  {key} ({typ}): {desc or '-'}")
+    return "\n".join(lines) if lines else json.dumps(info, indent=2)
+
+
+def _format_help_list(data: Dict[str, Any]) -> str:
+    lines = []
+    tool = data.get("tool_info", {})
+    if tool:
+        lines.append(f"{tool.get('name', 'Service')} — {tool.get('description', '')}")
+        lines.append(f"Version: {tool.get('version', '')}")
+        lines.append("")
+    commands = data.get("commands", {})
+    if commands:
+        lines.append("Commands:")
+        for cmd_name, cmd_info in sorted(commands.items()):
+            if isinstance(cmd_info, dict):
+                desc = cmd_info.get("description", "")
+                lines.append(f"  {cmd_name}: {desc or '(no description)'}")
+            else:
+                lines.append(f"  {cmd_name}")
+    return "\n".join(lines) if lines else json.dumps(data, indent=2)
+
+
+def _parse_params(args: List[str]) -> Dict[str, Any]:
+    out: Dict[str, Any] = {}
+    i = 0
+    while i < len(args):
+        arg = args[i]
+        if arg == "--params-json" and i + 1 < len(args):
+            try:
+                return json.loads(args[i + 1])
+            except json.JSONDecodeError as e:
+                raise ValueError(f"Invalid --params-json: {e}") from e
+        if arg.startswith("--") and "=" in arg:
+            key = arg[2:].split("=", 1)[0]
+            val = arg.split("=", 1)[1]
+            out[key] = val
+        elif arg.startswith("--") and i + 1 < len(args):
+            key = arg[2:]
+            out[key] = args[i + 1]
+            i += 1
+        elif "=" in arg:
+            key, val = arg.split("=", 1)
+            out[key] = val
+        i += 1
+    return out
+
+
+def _add_network_args(parser: argparse.ArgumentParser) -> None:
+    g = parser.add_argument_group("Connection (defaults: mTLS localhost:8009)")
+    g.add_argument("--host", default="127.0.0.1", help="Server host")
+    g.add_argument("--port", type=int, default=8009, help="Server port")
+    g.add_argument("--protocol", default="mtls", choices=("http", "https", "mtls"))
+    g.add_argument("--certs-dir", default=None, help="Directory for cert/key/ca paths")
+    g.add_argument("--cert", default=None, help="Client certificate path")
+    g.add_argument("--key", default=None, help="Client key path")
+    g.add_argument("--ca", default=None, help="CA certificate path")
+    g.add_argument("--timeout", type=float, default=300.0, help="Command timeout (s)")
+
+
+def _client_from_args(args: argparse.Namespace) -> SvoChunkerClient:
+    base = Path(args.certs_dir) if getattr(args, "certs_dir", None) else None
+    cert = getattr(args, "cert", None)
+    key = getattr(args, "key", None)
+    ca = getattr(args, "ca", None)
+    protocol = getattr(args, "protocol", "mtls")
+    if protocol == "mtls" and not cert and not key:
+        if base is None:
+            base = _PROJECT_ROOT / "mtls_certificates"
+        cert = str(base / "client" / "svo-chunker.crt")
+        key = str(base / "client" / "svo-chunker.key")
+        ca = str(base / "ca" / "ca.crt")
+    elif base and cert and not Path(cert).is_absolute():
+        cert = str(base / cert)
+    if base and key and not Path(key).is_absolute():
+        key = str(base / key)
+    if base and ca and not Path(ca).is_absolute():
+        ca = str(base / ca)
+    return SvoChunkerClient(
+        protocol=getattr(args, "protocol", "mtls"),
+        host=getattr(args, "host", "127.0.0.1"),
+        port=getattr(args, "port", 8009),
+        cert=cert or None,
+        key=key or None,
+        ca=ca or None,
+        timeout=getattr(args, "timeout", 300.0),
+        certs_dir=str(base) if base else None,
+    )
+
+
+async def _cmd_list(args: argparse.Namespace) -> int:
+    client = _client_from_args(args)
+    try:
+        async with client:
+            names = await client.list_commands()
+        for n in names:
+            print(n)
+        return 0
+    except SvoConnectionError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+async def _cmd_help(args: argparse.Namespace) -> int:
+    client = _client_from_args(args)
+    command_name = getattr(args, "command", None)
+    try:
+        async with client:
+            help_result = await client.help(command_name=command_name)
+        data = help_result.get("data", help_result)
+        if not isinstance(data, dict):
+            print(json.dumps(help_result, indent=2, ensure_ascii=False))
+            return 0
+        if command_name and (data.get("name") or data.get("schema")):
+            print(_format_help_for_command(data))
+        else:
+            print(_format_help_list(data))
+        return 0
+    except SvoConnectionError as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+async def _cmd_run(args: argparse.Namespace) -> int:
+    client = _client_from_args(args)
+    command = getattr(args, "command", None)
+    params = getattr(args, "params", {})
+    if not isinstance(command, str):
+        print("Error: command name required", file=sys.stderr)
+        return 1
+    try:
+        async with client:
+            result = await client.call(command, params)
+        print(json.dumps(result, indent=2, ensure_ascii=False))
+        return 0
+    except (
+        SvoConnectionError,
+        SvoTimeoutError,
+        SvoChunkingError,
+        SvoValidationError,
+    ) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+def _build_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="SVO Chunker client. Commands and help from server.",
+    )
+    _add_network_args(parser)
+    sub = parser.add_subparsers(dest="subcommand", required=True)
+
+    p_list = sub.add_parser("list", help="List available commands (from server)")
+    p_list.set_defaults(_run=_cmd_list)
+
+    p_help = sub.add_parser("help", help="Show help from server (all or one command)")
+    p_help.add_argument("command", nargs="?", default=None)
+    p_help.set_defaults(_run=_cmd_help)
+
+    p_run = sub.add_parser("run", help="Run a server command")
+    p_run.add_argument("command", help="Command name")
+    p_run.add_argument(
+        "params", nargs="*", default=[], help="key=value or --params-json"
+    )
+    p_run.set_defaults(_run=_cmd_run)
+
+    return parser
+
+
+def main() -> int:
+    parser = _build_parser()
+    args = parser.parse_args()
+
+    if getattr(args, "subcommand", None) == "run":
+        try:
+            args.params = _parse_params(getattr(args, "params", []))
+        except ValueError as e:
+            print(f"Error: {e}", file=sys.stderr)
+            return 1
+
+    return asyncio.run(args._run(args))
+
+
+if __name__ == "__main__":
+    sys.exit(main())