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

svo_client/cli_chunk.py

@@ -0,0 +1,386 @@
+"""
+CLI for chunk and health commands.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import argparse
+import asyncio
+import base64
+import json
+import sys
+from pathlib import Path
+from typing import Any, Awaitable, Callable, Dict, Optional
+
+from svo_client import SvoChunkerClient
+from svo_client.client import build_file_chunk_params
+from svo_client.config import ClientConfig
+from svo_client.constants import MAX_CLI_FILE_CHUNK_UPLOAD_BYTES
+from svo_client.exceptions import (
+    SvoChunkingError,
+    SvoClientError,
+    SvoConnectionError,
+    SvoTimeoutError,
+    SvoValidationError,
+)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="SVO Chunker Client - Chunk text using SVO Chunker service",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    parser.add_argument("--protocol", choices=["http", "https", "mtls"], default=None)
+    parser.add_argument("--host", default=None)
+    parser.add_argument("--port", type=int, default=None)
+    parser.add_argument("--token-header", default=None)
+    parser.add_argument("--token", default=None)
+    parser.add_argument("--cert", default=None)
+    parser.add_argument("--key", default=None)
+    parser.add_argument("--ca", default=None)
+    parser.add_argument("--check-hostname", action="store_true", default=None)
+    parser.add_argument(
+        "--timeout",
+        type=float,
+        default=None,
+        help="Command timeout in seconds. Omit for default (300). Use with --no-timeout to disable.",
+    )
+    parser.add_argument(
+        "--no-timeout",
+        action="store_true",
+        help="No timeout; wait until server completes (e.g. for very large texts).",
+    )
+    parser.add_argument("--config", default=None)
+    parser.add_argument("--window", type=int, default=3)
+    parser.add_argument(
+        "--use-sv",
+        action="store_true",
+        default=False,
+        help="Run SV (sentence-verb) chunking stage. Default: False.",
+    )
+    parser.add_argument(
+        "--aggregation-mode",
+        choices=["sentence", "none", "paragraph"],
+        default=None,
+        help="Optional aggregation mode sent to chunk/file-chunk.",
+    )
+    parser.add_argument(
+        "--chunk-set",
+        default=None,
+        help=(
+            "Optional chunk_set preset (server config.chunk_sets). "
+            "Known presets: plain_text, technical_text, docstring, scientific_text, "
+            "fiction, chat, log. Other names are forwarded as-is; the server validates "
+            "unknown names."
+        ),
+    )
+    parser.add_argument(
+        "--respect-structural-blocks",
+        action=argparse.BooleanOptionalAction,
+        default=None,
+        help=(
+            "Respect structural block boundaries during aggregation. "
+            "Use --no-respect-structural-blocks to disable."
+        ),
+    )
+    parser.add_argument("--language", default=None)
+    parser.add_argument("--source-id", default=None)
+    parser.add_argument("--project", default=None)
+    parser.add_argument("--unit-id", default=None)
+    parser.add_argument("--chunking-version", default="1.0")
+    parser.add_argument("--input", "-i", default=None)
+    parser.add_argument(
+        "--output",
+        "-o",
+        default=None,
+        help="Output file path for chunk result (required for chunk command)",
+    )
+    parser.add_argument("--format", choices=["json", "pretty"], default="pretty")
+    parser.add_argument(
+        "--filter-name",
+        default=None,
+        help=(
+            "Optional filter registry name for file-chunk (server may infer from "
+            "extension when omitted)"
+        ),
+    )
+    parser.add_argument(
+        "--type",
+        "--chunk-type",
+        dest="chunk_type",
+        default=None,
+        help=(
+            "Optional semantic/document metadata type sent as request field 'type' "
+            "(for example DocBlock, Draft, Message, Log)."
+        ),
+    )
+    parser.add_argument(
+        "--no-download",
+        action="store_true",
+        help=(
+            "With file-chunk: do not download the outbound JSON artifact; "
+            "print RPC result metadata to stdout."
+        ),
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="store_true",
+        help=(
+            "With file-chunk: print WebSocket job status lines to stderr (stdout "
+            "JSON contract unchanged)."
+        ),
+    )
+    parser.add_argument(
+        "command",
+        nargs="?",
+        choices=["chunk", "health", "file-chunk"],
+        default="chunk",
+    )
+    return parser
+
+
+async def chunk_command(
+    client: SvoChunkerClient, text: str, args: argparse.Namespace
+) -> None:
+    chunks = await client.chunk(
+        text=text,
+        window=args.window,
+        language=args.language,
+        source_id=args.source_id,
+        project=args.project,
+        unit_id=args.unit_id,
+        chunking_version=args.chunking_version,
+        use_sv=getattr(args, "use_sv", False),
+        chunk_type=args.chunk_type,
+        aggregation_mode=args.aggregation_mode,
+        respect_structural_blocks=args.respect_structural_blocks,
+        chunk_set=getattr(args, "chunk_set", None),
+    )
+    if args.format == "json":
+        output = json.dumps(chunks, ensure_ascii=False, indent=2)
+    else:
+        lines = [f"Chunked {len(chunks)} chunks:\n"]
+        for i, chunk in enumerate(chunks, 1):
+            lines.append(f"Chunk {i}:")
+            lines.append(f"  UUID: {chunk.get('uuid')}")
+            lines.append(f"  Type: {chunk.get('type')}")
+            lines.append(f"  Language: {chunk.get('language')}")
+            lines.append(f"  Body length: {len(chunk.get('body', ''))}")
+            lines.append(f"  Text preview: {chunk.get('text', '')[:100]}...")
+            lines.append("")
+        output = "\n".join(lines)
+    output_path = Path(args.output)
+    output_path.write_text(output, encoding="utf-8")
+    written_back = output_path.read_text(encoding="utf-8")
+    if written_back != output:
+        raise IOError(f"Output verification failed for {output_path}")
+
+
+async def health_command(client: SvoChunkerClient) -> None:
+    health = await client.health()
+    print(json.dumps(health, ensure_ascii=False, indent=2))
+
+
+def _file_chunk_ws_status_line(msg: Dict[str, Any]) -> Optional[str]:
+    """Build a short stderr line from adapter ``status_hook`` payloads, or None."""
+    if not isinstance(msg, dict) or not msg:
+        return None
+    parts: list[str] = []
+    ev = msg.get("event") or msg.get("type")
+    if ev:
+        parts.append(str(ev))
+    prog = msg.get("progress_percent")
+    if prog is None:
+        prog = msg.get("progress")
+    if prog is not None:
+        parts.append(f"{prog}%")
+    desc = msg.get("description") or msg.get("message")
+    step = msg.get("step")
+    if isinstance(desc, str) and desc.strip():
+        parts.append(desc.strip()[:160])
+    elif isinstance(step, str) and step.strip():
+        parts.append(step.strip()[:160])
+    if not parts:
+        return None
+    return "file-chunk: " + " — ".join(parts)
+
+
+async def file_chunk_command(
+    client: SvoChunkerClient, args: argparse.Namespace
+) -> None:
+    """Server ``file_chunk`` RPC: optional filter, then optional artifact download."""
+    input_path = Path(args.input)
+    raw_bytes = input_path.read_bytes()
+    if len(raw_bytes) > MAX_CLI_FILE_CHUNK_UPLOAD_BYTES:
+        print(
+            f"Error: file too large for base64 JSON-RPC upload "
+            f"({len(raw_bytes)} bytes, limit {MAX_CLI_FILE_CHUNK_UPLOAD_BYTES}). "
+            "Use transfer_id upload or multipart when supported by your deployment.",
+            file=sys.stderr,
+        )
+        raise SystemExit(1)
+    encoded = base64.b64encode(raw_bytes).decode("ascii")
+
+    params = build_file_chunk_params(
+        filename=input_path.name,
+        file_content_base64=encoded,
+        filter_name=args.filter_name,
+        window=args.window,
+        chunk_type=args.chunk_type,
+        language=args.language,
+        source_id=args.source_id,
+        project=args.project,
+        unit_id=args.unit_id,
+        chunking_version=args.chunking_version,
+        use_sv=getattr(args, "use_sv", False),
+        aggregation_mode=args.aggregation_mode,
+        respect_structural_blocks=args.respect_structural_blocks,
+        chunk_set=getattr(args, "chunk_set", None),
+    )
+
+    print(
+        "Waiting for server (no CLI progress on stdout; see server logs). "
+        "Use --verbose for WebSocket status lines on stderr.",
+        file=sys.stderr,
+        flush=True,
+    )
+
+    verbose_hook: Optional[Callable[[Dict[str, Any]], Awaitable[None]]] = None
+    if getattr(args, "verbose", False):
+
+        async def _verbose_status_hook(msg: Dict[str, Any]) -> None:
+            line = _file_chunk_ws_status_line(msg)
+            if line:
+                print(line, file=sys.stderr, flush=True)
+
+        verbose_hook = _verbose_status_hook
+
+    download_path = None if args.no_download else str(Path(args.output))
+    data = await client.file_chunk(
+        params,
+        download_path=download_path,
+        status_hook=verbose_hook,
+    )
+
+    if args.no_download:
+        if args.format == "json":
+            print(json.dumps(data, ensure_ascii=False, indent=2))
+        else:
+            print(f"transfer_id: {data.get('transfer_id')}")
+            print(f"filename: {data.get('filename')}")
+            print(f"filter_name: {data.get('filter_name')}")
+            meta = data.get("metadata")
+            if isinstance(meta, dict):
+                for k, v in meta.items():
+                    print(f"{k}: {v}")
+        return
+
+    if args.format == "json":
+        print(
+            json.dumps(
+                {"saved": args.output, "result": data},
+                ensure_ascii=False,
+                indent=2,
+            )
+        )
+    else:
+        print(f"Artifact written to {args.output}")
+        print(f"transfer_id={data.get('transfer_id')}")
+        print(f"filter_name={data.get('filter_name')}")
+
+
+async def main_async() -> int:
+    parser = create_parser()
+    args = parser.parse_args()
+
+    if args.command == "file-chunk":
+        if not args.input:
+            parser.error("argument --input/-i is required for file-chunk command")
+        if not args.no_download and not args.output:
+            parser.error(
+                "argument --output/-o is required for file-chunk unless "
+                "--no-download is set"
+            )
+        if args.no_timeout is False and args.timeout is None:
+            args.no_timeout = True
+    elif args.command != "health" and not args.output:
+        parser.error(
+            "argument --output/-o is required for chunk command "
+            "to save retrieval result"
+        )
+
+    cli_args = {}
+    for key, value in vars(args).items():
+        if key in (
+            "command",
+            "input",
+            "output",
+            "format",
+            "window",
+            "language",
+            "source_id",
+            "project",
+            "unit_id",
+            "chunking_version",
+            "aggregation_mode",
+            "chunk_set",
+            "respect_structural_blocks",
+            "config",
+            "use_sv",
+            "no_timeout",
+            "filter_name",
+            "chunk_type",
+            "no_download",
+            "verbose",
+        ):
+            continue
+        if key == "timeout" and args.no_timeout:
+            cli_args["timeout"] = 0  # no timeout
+            continue
+        if value is not None:
+            cli_args[key.replace("-", "_")] = value
+
+    config_manager = ClientConfig(config_file=args.config, cli_args=cli_args)
+    client_config = config_manager.get_client_config()
+
+    try:
+        async with SvoChunkerClient(**client_config) as client:
+            if args.command == "health":
+                await health_command(client)
+            elif args.command == "file-chunk":
+                await file_chunk_command(client, args)
+            else:
+                if args.input:
+                    text = Path(args.input).read_text(encoding="utf-8")
+                else:
+                    text = sys.stdin.read()
+                if not text.strip():
+                    print("Error: Empty input text", file=sys.stderr)
+                    return 1
+                await chunk_command(client, text, args)
+    except (
+        SvoClientError,
+        SvoChunkingError,
+        SvoConnectionError,
+        SvoTimeoutError,
+        SvoValidationError,
+    ) as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+    except KeyboardInterrupt:
+        print("\nInterrupted", file=sys.stderr)
+        return 130
+    except Exception as e:
+        print(f"Unexpected error: {e}", file=sys.stderr)
+        return 1
+    return 0
+
+
+def cli_entry_point() -> None:
+    sys.exit(asyncio.run(main_async()))
+
+
+if __name__ == "__main__":
+    cli_entry_point()