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

svo_client/config.py

@@ -0,0 +1,149 @@
+"""
+Configuration management for SVO Chunker client.
+
+Hierarchy: CLI args > env > config file.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+import json
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+
+class ClientConfig:
+    """Load client-side settings for :class:`~svo_client.client.SvoChunkerClient`.
+
+    Priority: **CLI overrides** passed to the constructor, then **environment variables**
+    (see ``ENV_PREFIX`` + mapping in :meth:`_load_from_env`), then **JSON file** from
+    ``config_file`` or the first existing path in ``DEFAULT_CONFIG_PATHS``.
+
+    Optional keys are for **operator documentation** and local tooling only. For example,
+    ``file_batch_size`` may mirror the chunker server ``config`` value so scripts and humans
+    know the batch width used by ``file_chunk``; it is **not** sent on JSON-RPC and does not
+    change server behavior unless the server reads its own config.
+    """
+
+    ENV_PREFIX = "SVO_CHUNKER_CLIENT_"
+
+    DEFAULT_CONFIG_PATHS = [
+        "svo_client_config.json",
+        "~/.svo_chunker_client.json",
+        "/etc/svo_chunker_client.json",
+    ]
+
+    def __init__(
+        self,
+        config_file: Optional[str] = None,
+        cli_args: Optional[Dict[str, Any]] = None,
+    ):
+        self.cli_args = cli_args or {}
+        self.config_file = config_file
+        self._config: Dict[str, Any] = {}
+
+    def load(self) -> Dict[str, Any]:
+        config = {}
+        config_file_path = self._find_config_file()
+        if config_file_path:
+            config.update(self._load_config_file(config_file_path))
+        config.update(self._load_from_env())
+        config.update(self.cli_args)
+        self._config = config
+        return config
+
+    def _find_config_file(self) -> Optional[Path]:
+        if self.config_file:
+            path = Path(self.config_file).expanduser()
+            if path.exists():
+                return path
+            return None
+        for config_path in self.DEFAULT_CONFIG_PATHS:
+            path = Path(config_path).expanduser()
+            if path.exists():
+                return path
+        return None
+
+    def _load_config_file(self, config_path: Path) -> Dict[str, Any]:
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                return json.load(f)
+        except Exception as e:
+            raise ValueError(f"Failed to load config file {config_path}: {e}") from e
+
+    def _load_from_env(self) -> Dict[str, Any]:
+        config: Dict[str, Any] = {}
+        env_prefix = self.ENV_PREFIX
+        env_mapping = {
+            f"{env_prefix}PROTOCOL": "protocol",
+            f"{env_prefix}HOST": "host",
+            f"{env_prefix}PORT": "port",
+            f"{env_prefix}TOKEN_HEADER": "token_header",
+            f"{env_prefix}TOKEN": "token",
+            f"{env_prefix}CERT": "cert",
+            f"{env_prefix}KEY": "key",
+            f"{env_prefix}CA": "ca",
+            f"{env_prefix}CHECK_HOSTNAME": "check_hostname",
+            f"{env_prefix}TIMEOUT": "timeout",
+            f"{env_prefix}FILE_BATCH_SIZE": "file_batch_size",
+        }
+        for env_var, config_key in env_mapping.items():
+            value = os.getenv(env_var)
+            if value is not None:
+                if config_key in ("port", "timeout"):
+                    try:
+                        config[config_key] = (
+                            int(value) if config_key == "port" else float(value)
+                        )
+                    except ValueError:
+                        pass
+                elif config_key == "file_batch_size":
+                    try:
+                        config[config_key] = int(value)
+                    except ValueError:
+                        pass
+                elif config_key == "check_hostname":
+                    config[config_key] = value.lower() in (
+                        "true",
+                        "1",
+                        "yes",
+                        "on",
+                    )
+                else:
+                    config[config_key] = value
+        return config
+
+    def get_client_config(self) -> Dict[str, Any]:
+        """Get kwargs for SvoChunkerClient."""
+        config = self.load()
+        raw_timeout = config.get("timeout", 300.0)
+        # None or 0 = no timeout (wait until completion)
+        timeout = None if raw_timeout is None or raw_timeout == 0 else raw_timeout
+        raw_file_batch = config.get("file_batch_size")
+        file_batch_size: Optional[int]
+        if raw_file_batch is None:
+            file_batch_size = None
+        else:
+            try:
+                file_batch_size = int(raw_file_batch)
+            except (TypeError, ValueError):
+                file_batch_size = None
+
+        client_config = {
+            "protocol": config.get("protocol", "https"),
+            "host": config.get("host", "127.0.0.1"),
+            "port": config.get("port", 8009),
+            "token_header": config.get("token_header"),
+            "token": config.get("token"),
+            "cert": config.get("cert"),
+            "key": config.get("key"),
+            "ca": config.get("ca"),
+            "check_hostname": config.get("check_hostname", False),
+            "timeout": timeout,
+            "file_batch_size": file_batch_size,
+        }
+        # Include timeout even when None (no-timeout mode)
+        return {
+            k: v for k, v in client_config.items() if v is not None or k == "timeout"
+        }

svo_client/connect_defaults.py

@@ -0,0 +1,230 @@
+"""
+Shared defaults for connecting to a local chunker via ``SvoChunkerClient``.
+
+Resolves mTLS certificate paths under the project tree when present; otherwise
+uses plain HTTP to ``127.0.0.1:8009``.
+
+Author: Vasiliy Zdanovskiy
+email: vasilyvz@gmail.com
+"""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any, Dict, Optional, Tuple, Union
+from urllib.parse import urlparse
+
+
+def resolve_mtls_triplet(
+    project_root: Path,
+) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """Return (cert, key, ca) paths if all three exist, else (None, None, None)."""
+    for cert, key, ca in (
+        (
+            project_root
+            / "mtls_certificates/mtls_certificates/client/code-analysis.crt",
+            project_root
+            / "mtls_certificates/mtls_certificates/client/code-analysis.key",
+            project_root / "mtls_certificates/mtls_certificates/ca/ca.crt",
+        ),
+        (
+            project_root / "mtls_certificates/client/code-analysis.crt",
+            project_root / "mtls_certificates/client/code-analysis.key",
+            project_root / "mtls_certificates/ca/ca.crt",
+        ),
+        (
+            project_root / "mtls_certificates/client/svo-chunker.crt",
+            project_root / "mtls_certificates/client/svo-chunker.key",
+            project_root / "mtls_certificates/ca/ca.crt",
+        ),
+    ):
+        if cert.is_file() and key.is_file() and ca.is_file():
+            return str(cert), str(key), str(ca)
+    return None, None, None
+
+
+def default_chunker_client_kwargs(
+    project_root: Optional[Path] = None,
+    *,
+    host: str = "127.0.0.1",
+    port: int = 8009,
+    timeout: float = 300.0,
+) -> Dict[str, Any]:
+    """
+    Keyword arguments for ``SvoChunkerClient(...)`` for local development.
+
+    Uses HTTPS + mTLS when certificate files are found under *project_root*,
+    otherwise ``protocol=http`` without certs.
+    """
+    root = project_root or Path.cwd()
+    cert, key, ca = resolve_mtls_triplet(root)
+    if cert and key and ca:
+        return {
+            "protocol": "https",
+            "host": host,
+            "port": port,
+            "cert": cert,
+            "key": key,
+            "ca": ca,
+            "check_hostname": False,
+            "timeout": timeout,
+        }
+    return {
+        "protocol": "http",
+        "host": host,
+        "port": port,
+        "timeout": timeout,
+    }
+
+
+def chunker_client_kwargs_from_base_url(
+    base_url: str,
+    project_root: Optional[Path] = None,
+    *,
+    timeout: float = 300.0,
+) -> Dict[str, Any]:
+    """
+    Build ``SvoChunkerClient`` kwargs from a base URL like ``http://127.0.0.1:8009``.
+
+    HTTPS uses mTLS paths from ``resolve_mtls_triplet`` when files exist; otherwise
+    HTTPS without client cert may fail at TLS handshake (caller responsibility).
+    """
+    parsed = urlparse(base_url.strip())
+    scheme = (parsed.scheme or "http").lower()
+    host = parsed.hostname or "127.0.0.1"
+    port = parsed.port
+    if port is None:
+        port = 443 if scheme in ("https", "mtls") else 8009
+
+    root = project_root or Path.cwd()
+    cert, key, ca = resolve_mtls_triplet(root)
+    # region agent log
+    from svo_client.debug_ndjson import agent_debug_log
+
+    agent_debug_log(
+        "H1",
+        "connect_defaults:chunker_client_kwargs_from_base_url",
+        "mtls triplet resolution",
+        {
+            "base_url": base_url.strip(),
+            "scheme": scheme,
+            "host": host,
+            "port": port,
+            "triplet_found": bool(cert and key and ca),
+            "resolve_mtls_paths_checked": "code-analysis then svo-chunker",
+        },
+    )
+    # endregion
+    if scheme in ("https", "mtls") and cert and key and ca:
+        return {
+            "protocol": "https",
+            "host": host,
+            "port": port,
+            "cert": cert,
+            "key": key,
+            "ca": ca,
+            "check_hostname": False,
+            "timeout": timeout,
+        }
+    if scheme in ("https", "mtls"):
+        # region agent log
+        agent_debug_log(
+            "H1",
+            "connect_defaults:chunker_client_kwargs_from_base_url",
+            "https without client cert triplet — adapter may omit mTLS",
+            {"scheme": scheme, "outer_timeout": timeout},
+        )
+        # endregion
+        return {
+            "protocol": "https",
+            "host": host,
+            "port": port,
+            "timeout": timeout,
+        }
+    return {
+        "protocol": "http",
+        "host": host,
+        "port": port,
+        "timeout": timeout,
+    }
+
+
+def chunker_client_kwargs_from_chunker_server_config(
+    chunker_config_path: Union[str, Path],
+    *,
+    host: str = "localhost",
+    project_root: Optional[Path] = None,
+    timeout: Optional[float] = None,
+) -> Dict[str, Any]:
+    """
+    Build ``SvoChunkerClient`` kwargs from a **chunker server** JSON (e.g.
+    ``config/svo_chunker_container.json``): ``protocol``, ``port``, optional
+    ``check_hostname`` from ``server.ssl``.
+
+    *host* is **not** taken from the file (container configs often use
+    ``0.0.0.0``); pass ``localhost`` / ``127.0.0.1`` for local calls.
+
+    Client mTLS material is **not** the server's ``ssl.cert``/``key`` in that
+    file (those are in-container server paths). When no usable paths exist on
+    disk, :func:`resolve_mtls_triplet` under *project_root* supplies the client
+    cert, key, and CA (same as local dev).
+    """
+    path = Path(chunker_config_path).expanduser().resolve()
+    with open(path, "r", encoding="utf-8") as fh:
+        data = json.load(fh)
+    if not isinstance(data, dict):
+        raise ValueError("chunker config root must be a JSON object")
+
+    srv = data.get("server") if isinstance(data.get("server"), dict) else {}
+    transport = (
+        data.get("transport") if isinstance(data.get("transport"), dict) else {}
+    )
+    raw_proto = srv.get("protocol") or transport.get("type") or "https"
+    protocol = str(raw_proto).strip().lower()
+    if protocol == "mtls":
+        protocol = "https"
+
+    port_raw = srv.get("port", transport.get("port", 8009))
+    try:
+        port = int(port_raw)
+    except (TypeError, ValueError) as e:
+        raise ValueError(f"invalid port in chunker config: {port_raw!r}") from e
+
+    ssl_block = srv.get("ssl") if isinstance(srv.get("ssl"), dict) else {}
+    ch_raw = ssl_block.get("check_hostname")
+    if isinstance(ch_raw, bool):
+        check_hostname = ch_raw
+    else:
+        check_hostname = False
+
+    if timeout is None:
+        emb = data.get("embedding_client")
+        if isinstance(emb, dict):
+            t_emb = emb.get("timeout")
+            if isinstance(t_emb, (int, float)) and t_emb > 0:
+                timeout = float(t_emb)
+        if timeout is None:
+            timeout = 300.0
+
+    root = project_root or Path.cwd()
+    cert, key, ca = resolve_mtls_triplet(root)
+
+    out: Dict[str, Any] = {
+        "protocol": protocol,
+        "host": host,
+        "port": port,
+        "check_hostname": check_hostname,
+        "timeout": float(timeout),
+    }
+    if protocol in ("https", "mtls") and cert and key and ca:
+        out["protocol"] = "https"
+        out["cert"] = cert
+        out["key"] = key
+        out["ca"] = ca
+    elif protocol in ("https", "mtls"):
+        out["protocol"] = "https"
+    else:
+        out["protocol"] = "http"
+
+    return {k: v for k, v in out.items() if v is not None or k == "timeout"}

svo_client/constants.py

@@ -0,0 +1,4 @@
+"""Constants used by the standalone SVO client."""
+
+MAX_CLI_FILE_CHUNK_UPLOAD_BYTES: int = 48 * 1024 * 1024
+"""Largest raw file accepted by the base64 ``file_chunk`` CLI path."""