macore-client 0.1.4__py3-none-any.whl

macore_client/__init__.py

@@ -0,0 +1,9 @@
+# client/macore_client/__init__.py
+# Author: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+# Project: model_access_core (71b1e006-b777-4edb-854e-f0a47120f793)
+"""Client package for the Model Access Core (MAC) server."""
+
+from macore_client.client import MacClient
+
+__version__ = "0.1.4"
+__all__ = ["MacClient", "__version__"]

macore_client/cli.py

@@ -0,0 +1,77 @@
+# client/macore_client/cli.py
+# Author: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+# Project: model_access_core (71b1e006-b777-4edb-854e-f0a47120f793)
+"""``macore-client`` console script: one subcommand per MAC command."""
+
+from __future__ import annotations
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+from typing import Any
+
+from macore_client.client import COMMANDS, MacClient
+
+
+def default_base_url() -> str:
+    """Resolve the server base URL from the environment."""
+    return os.environ.get("MAC_VERIFY_BASE_URL", "http://127.0.0.1:8010")
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the CLI parser with one subcommand per client command method."""
+    parser = argparse.ArgumentParser(
+        prog="macore-client",
+        description="Call one Model Access Core server command over JSON-RPC.",
+    )
+    parser.add_argument(
+        "--base-url",
+        default=None,
+        help="Adapter base URL (default: env MAC_VERIFY_BASE_URL or http://127.0.0.1:8010)",
+    )
+    parser.add_argument("--timeout", type=float, default=None, help="HTTP timeout seconds")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    for command in COMMANDS:
+        sub = subparsers.add_parser(command.replace("_", "-"), help=f"Run {command}")
+        sub.add_argument(
+            "--params",
+            default="{}",
+            help="Command parameters as a JSON object string",
+        )
+    return parser
+
+
+async def _run(base_url: str, timeout: float | None, command: str, params: dict[str, Any]) -> Any:
+    client = MacClient(base_url, timeout=timeout)
+    try:
+        return await client.call(command, params)
+    finally:
+        await client.close()
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point of the ``macore-client`` command."""
+    args = build_parser().parse_args(argv)
+    command = str(args.command).replace("-", "_")
+    try:
+        params = json.loads(args.params)
+    except json.JSONDecodeError as exc:
+        print(f"macore-client: --params is not valid JSON: {exc}", file=sys.stderr)
+        return 2
+    if not isinstance(params, dict):
+        print("macore-client: --params must be a JSON object", file=sys.stderr)
+        return 2
+    base_url = args.base_url or default_base_url()
+    try:
+        result = asyncio.run(_run(base_url, args.timeout, command, params))
+    except Exception as exc:  # surface transport/command failure as text, not traceback
+        print(f"macore-client: {command} failed: {exc}", file=sys.stderr)
+        return 1
+    print(json.dumps(result, ensure_ascii=False, indent=2, default=str))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

macore_client/client.py

@@ -0,0 +1,146 @@
+# client/macore_client/client.py
+# Author: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+# Project: model_access_core (71b1e006-b777-4edb-854e-f0a47120f793)
+"""The MAC client: one method per public MAC command.
+
+Wraps the ``mcp_proxy_adapter`` framework JSON-RPC client. No method builds a
+URL, a JSON-RPC envelope or a raw transport payload; transport, protocol
+selection, serialization and queued-job handling all belong to the framework
+client. Every method mirrors a command the MAC server registers, with the same
+name, so client and server read against each other without a translation table.
+"""
+
+from __future__ import annotations
+
+import contextlib
+import sys
+from typing import Any
+from urllib.parse import urlparse
+
+
+def _import_jsonrpc_client() -> Any:
+    """Import the framework client with its import-time banner kept off stdout."""
+    with contextlib.redirect_stdout(sys.stderr):
+        from mcp_proxy_adapter.client.jsonrpc_client.client import JsonRpcClient
+    return JsonRpcClient
+
+# Public MAC commands, one client method each. model_selftest is queued on the
+# server; the rest answer inline.
+COMMANDS: tuple[str, ...] = (
+    "health",
+    "model_health",
+    "model_providers",
+    "model_provider_status",
+    "model_vram_status",
+    "model_queue_status",
+    "model_session_create",
+    "model_session_get",
+    "model_session_delete",
+    "model_chat",
+    "model_count_tokens",
+    "model_estimate_request_capacity",
+    "model_request_status",
+    "model_request_cancel",
+    "model_cache_create",
+    "model_cache_set_active",
+    "model_cache_list",
+    "model_cache_delete",
+    "model_selftest",
+    "hardware_calibration",
+)
+
+_QUEUED_COMMANDS: frozenset[str] = frozenset({"model_selftest"})
+
+
+def command_methods() -> tuple[str, ...]:
+    """Return the client's public command-method names (for surface checks)."""
+    return COMMANDS
+
+
+def _unwrap(result: Any) -> Any:
+    """Unwrap the unified-execution envelope down to the command result."""
+    seen = 0
+    while isinstance(result, dict) and seen < 8:
+        seen += 1
+        if result.get("mode") in {"immediate", "queued"} and "result" in result:
+            result = result["result"]
+            continue
+        if "result" in result and set(result.keys()) <= {"result", "job_id", "status", "queued", "command", "raw_status", "mode"}:
+            result = result["result"]
+            continue
+        break
+    return result
+
+
+class MacClient:
+    """Full-surface client for one Model Access Core server.
+
+    Attributes:
+        transport: The framework JSON-RPC client carrying every request.
+    """
+
+    def __init__(
+        self,
+        base_url: str = "http://127.0.0.1:8010",
+        *,
+        token: str | None = None,
+        token_header: str | None = None,
+        cert: str | None = None,
+        key: str | None = None,
+        ca: str | None = None,
+        check_hostname: bool = False,
+        timeout: float | None = None,
+    ) -> None:
+        parsed = urlparse(base_url)
+        protocol = parsed.scheme or "http"
+        host = parsed.hostname or "127.0.0.1"
+        port = parsed.port or (443 if protocol == "https" else 80)
+        json_rpc_client = _import_jsonrpc_client()
+        self.transport = json_rpc_client(
+            protocol=protocol,
+            host=host,
+            port=port,
+            token=token,
+            token_header=token_header,
+            cert=cert,
+            key=key,
+            ca=ca,
+            check_hostname=check_hostname,
+            timeout=timeout,
+        )
+
+    async def call(self, command: str, params: dict[str, Any] | None = None) -> Any:
+        """Execute one MAC command and return its unwrapped result."""
+        if command in _QUEUED_COMMANDS:
+            raw = await self.transport.execute_command_unified(
+                command,
+                params or {},
+                auto_poll=True,
+            )
+        else:
+            raw = await self.transport.execute_command_unified(
+                command,
+                params or {},
+                expect_queue=False,
+            )
+        return _unwrap(raw)
+
+    async def close(self) -> None:
+        """Close the underlying transport."""
+        close = getattr(self.transport, "close", None)
+        if close is not None:
+            await close()
+
+
+def _make_method(command: str) -> Any:
+    async def method(self: MacClient, params: dict[str, Any] | None = None) -> Any:
+        return await self.call(command, params)
+
+    method.__name__ = command
+    method.__qualname__ = f"MacClient.{command}"
+    method.__doc__ = f"Execute the MAC ``{command}`` command."
+    return method
+
+
+for _command in COMMANDS:
+    setattr(MacClient, _command, _make_method(_command))

macore_client/live_check.py

@@ -0,0 +1,109 @@
+# client/macore_client/live_check.py
+# Author: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+# Project: model_access_core (71b1e006-b777-4edb-854e-f0a47120f793)
+"""Live acceptance checks against a deployed MAC server.
+
+Shared verbatim between the installed client's ``pipeline`` console script and
+the server repository, so there is exactly one runner for every context the
+pipeline contract names: local verification, post-deploy acceptance, and the
+post-start smoke run.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from typing import Any
+
+from macore_client.client import MacClient
+
+
+def _base_url() -> str:
+    return os.environ.get("MAC_VERIFY_BASE_URL", "http://127.0.0.1:8010")
+
+
+def _timeout() -> float:
+    raw = os.environ.get("MAC_VERIFY_TIMEOUT", "300")
+    try:
+        return float(raw)
+    except ValueError:
+        return 300.0
+
+
+async def _with_client(coro: Any) -> int:
+    client = MacClient(_base_url(), timeout=_timeout())
+    try:
+        return await coro(client)
+    finally:
+        await client.close()
+
+
+def run_health_live() -> int:
+    """The deployed server answers health and model_health."""
+
+    async def check(client: MacClient) -> int:
+        health = await client.call("health")
+        model_health = await client.call("model_health")
+        data = model_health.get("data") if isinstance(model_health, dict) else None
+        adapter = (data or {}).get("adapter") if isinstance(data, dict) else None
+        registry = (data or {}).get("registry") if isinstance(data, dict) else None
+        providers = (registry or {}).get("providers") if isinstance(registry, dict) else None
+        if not isinstance(health, dict):
+            print("FAIL health-live: health returned no object")
+            return 1
+        if adapter != "ok" or not isinstance(providers, int) or providers < 1:
+            print(f"FAIL health-live: adapter={adapter!r} providers={providers!r}")
+            return 1
+        print(f"PASS health-live: adapter=ok providers={providers}")
+        return 0
+
+    return asyncio.run(_with_client(check))
+
+
+def run_providers_live() -> int:
+    """The deployed server lists at least one provider with models."""
+
+    async def check(client: MacClient) -> int:
+        result = await client.call("model_providers")
+        data = result.get("data") if isinstance(result, dict) else None
+        providers = data if isinstance(data, list) else None
+        if providers is None and isinstance(data, dict):
+            providers = data.get("providers") if isinstance(data.get("providers"), list) else None
+        if not isinstance(providers, list) or not providers:
+            print(f"FAIL providers-live: no providers in {str(result)[:200]}")
+            return 1
+        names = [p.get("provider_id") for p in providers if isinstance(p, dict)]
+        print(f"PASS providers-live: {len(providers)} providers: {', '.join(map(str, names))}")
+        return 0
+
+    return asyncio.run(_with_client(check))
+
+
+def run_selftest_live() -> int:
+    """Drive the server's own full live regression (model_selftest)."""
+
+    async def check(client: MacClient) -> int:
+        result = await client.call("model_selftest", {})
+        node: Any = result
+        for _ in range(6):
+            if isinstance(node, dict) and isinstance(node.get("data"), dict):
+                node = node["data"]
+                continue
+            break
+        if not isinstance(node, dict) or "exit_code" not in node:
+            print(f"FAIL selftest-live: unrecognized selftest result: {str(result)[:300]}")
+            return 1
+        ok = bool(node.get("ok"))
+        exit_code = int(node.get("exit_code") or 0)
+        passed = node.get("passed")
+        failed = node.get("failed")
+        n_pass = len(passed) if isinstance(passed, list) else 0
+        n_fail = len(failed) if isinstance(failed, list) else 0
+        line = f"selftest-live: ok={ok} exit_code={exit_code} passed={n_pass} failed={n_fail}"
+        if not ok or exit_code != 0 or n_pass == 0:
+            print(f"FAIL {line}")
+            return 1
+        print(f"PASS {line}")
+        return 0
+
+    return asyncio.run(_with_client(check))

macore_client/pipeline.py

@@ -0,0 +1,171 @@
+# client/macore_client/pipeline.py
+# Author: Vasiliy Zdanovskiy <vasilyvz@gmail.com>
+# Project: model_access_core (71b1e006-b777-4edb-854e-f0a47120f793)
+"""The ``pipeline`` console script: fleet acceptance contract for MAC.
+
+``pipeline`` with no arguments runs every check, ``pipeline <check>`` runs one
+named check, ``pipeline --list`` enumerates them. Repository-only checks
+(unit tests, config validation) detect the MAC repository from the current
+working directory and self-skip cleanly when the pipeline runs from an
+installed client elsewhere; live checks target ``MAC_VERIFY_BASE_URL``
+(default ``http://127.0.0.1:8010``).
+"""
+
+from __future__ import annotations
+
+import argparse
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Callable
+
+from macore_client.live_check import run_health_live, run_providers_live, run_selftest_live
+
+
+@dataclass(frozen=True)
+class Check:
+    """One named verification check.
+
+    Attributes:
+        name: Stable check name used on the command line.
+        description: One-line description shown by ``pipeline --list``.
+        run: Zero-argument callable returning an integer exit status, 0 for pass.
+    """
+
+    name: str
+    description: str
+    run: Callable[[], int]
+
+
+def _repo_root() -> Path | None:
+    """Return the MAC repository root when the cwd is inside it."""
+    cur = Path.cwd().resolve()
+    for candidate in (cur, *cur.parents):
+        marker = candidate / "pyproject.toml"
+        if marker.is_file() and (candidate / "model_access_core").is_dir():
+            try:
+                if 'name = "model_access_core"' in marker.read_text(encoding="utf-8"):
+                    return candidate
+            except OSError:
+                return None
+    return None
+
+
+def run_unit() -> int:
+    """Repository unit tests (pytest). Self-skips outside the repository."""
+    repo = _repo_root()
+    if repo is None:
+        print("SKIP unit: not inside the model_access_core repository")
+        return 0
+    proc = subprocess.run(
+        [sys.executable, "-m", "pytest", "-q"],
+        cwd=repo,
+        check=False,
+    )
+    print(f"{'PASS' if proc.returncode == 0 else 'FAIL'} unit: pytest exit={proc.returncode}")
+    return proc.returncode
+
+
+def run_config() -> int:
+    """Repository config placeholder validation. Self-skips outside the repository."""
+    repo = _repo_root()
+    if repo is None:
+        print("SKIP config: not inside the model_access_core repository")
+        return 0
+    config_path = repo / "configs" / "config.json"
+    if not config_path.is_file():
+        print(f"FAIL config: missing {config_path}")
+        return 1
+    try:
+        import json
+
+        from model_access_core.config.placeholders import find_unresolved_placeholders
+    except ImportError as exc:
+        print(f"FAIL config: model_access_core not importable: {exc}")
+        return 1
+    config = json.loads(config_path.read_text(encoding="utf-8"))
+    unresolved = find_unresolved_placeholders(config)
+    if unresolved:
+        print(f"FAIL config: unresolved placeholders: {unresolved}")
+        return 1
+    print("PASS config: no unresolved placeholders")
+    return 0
+
+
+def run_cli_surface() -> int:
+    """Verify the CLI covers the client surface exactly. Runs offline."""
+    from macore_client.cli import build_parser
+    from macore_client.client import command_methods
+
+    parser = build_parser()
+    subparsers = next(
+        action
+        for action in parser._actions  # noqa: SLF001 - argparse offers no public accessor
+        if isinstance(action, argparse._SubParsersAction)  # noqa: SLF001
+    )
+    exposed = {name.replace("-", "_") for name in subparsers.choices}
+    methods = set(command_methods())
+    if exposed != methods:
+        print(f"FAIL cli-surface: CLI vs client mismatch: {sorted(exposed ^ methods)}")
+        return 1
+    print(f"PASS cli-surface: {len(methods)} commands exposed")
+    return 0
+
+
+CHECKS: tuple[Check, ...] = (
+    Check("unit", "Repository: run the unit test suite (self-skips outside the repo).", run_unit),
+    Check("config", "Repository: config placeholder validation (self-skips outside the repo).", run_config),
+    Check("cli-surface", "Offline: the CLI exposes exactly the client's command surface.", run_cli_surface),
+    Check("health-live", "The deployed server answers health and model_health.", run_health_live),
+    Check("providers-live", "The deployed server lists at least one provider.", run_providers_live),
+    Check("selftest-live", "Drive the server's full live regression (model_selftest).", run_selftest_live),
+)
+
+
+def _run_all() -> int:
+    """Run every check in order without early exit."""
+    failed = 0
+    for check in CHECKS:
+        print(f"--- {check.name}", flush=True)
+        status = check.run()
+        print(f"{'PASS' if status == 0 else 'FAIL'} {check.name}", flush=True)
+        if status != 0:
+            failed += 1
+    print(f"pipeline summary: {len(CHECKS) - failed} passed, {failed} failed", flush=True)
+    return 0 if failed == 0 else 1
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Entry point of the ``pipeline`` command."""
+    parser = argparse.ArgumentParser(
+        prog="pipeline",
+        description="Run the MAC acceptance suite or a single named check.",
+    )
+    parser.add_argument("check", nargs="?", help="name of a single check to run")
+    parser.add_argument(
+        "--list",
+        action="store_true",
+        dest="list_checks",
+        help="list the available check names",
+    )
+    args = parser.parse_args(argv)
+
+    if args.list_checks:
+        for check in CHECKS:
+            print(f"{check.name}: {check.description}")
+        return 0
+
+    if args.check is not None:
+        for check in CHECKS:
+            if check.name == args.check:
+                return check.run()
+        print(f"unknown check: {args.check}")
+        print("available checks: " + ", ".join(check.name for check in CHECKS))
+        return 2
+
+    return _run_all()
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

macore_client-0.1.4.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: macore-client
+Version: 0.1.4
+Summary: Client and pipeline acceptance runner for the Model Access Core (MAC) server
+Requires-Python: >=3.11
+Requires-Dist: mcp-proxy-adapter>=8.10.15

macore_client-0.1.4.dist-info/RECORD

@@ -0,0 +1,9 @@
+macore_client/__init__.py,sha256=tBZ3_aagtOD4QW3b1rS8Dt1jEXbSKqww1ZMSkEBJ0ss,320
+macore_client/cli.py,sha256=77uk0JK3PoXrcWS-EXLpBsxcZSLJYj2XMiZMcLi2ApU,2694
+macore_client/client.py,sha256=9aJdr5LnmBvxHB7wk83T9i9FnznB-W6jDeSSHV2jafo,4708
+macore_client/live_check.py,sha256=rrfG03Bomx9ILiM5lE2ZGtknvcctSr_u9eZaVNsN6LU,4154
+macore_client/pipeline.py,sha256=-63x4grFLDfCtZ66EuArOlQW6CjBph6PYeTf-A6BUqc,6067
+macore_client-0.1.4.dist-info/METADATA,sha256=7kvHeGf4uWOFa7kq_Yuq4X4Aa7KD10GrBb9PWZdkBKQ,209
+macore_client-0.1.4.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+macore_client-0.1.4.dist-info/entry_points.txt,sha256=Wz1Y2YAr79QX41nO-QK-IENtURFDhS4itel2OrFmcIw,96
+macore_client-0.1.4.dist-info/RECORD,,

macore_client-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.31.0
+Root-Is-Purelib: true
+Tag: py3-none-any

macore_client-0.1.4.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+macore-client = macore_client.cli:main
+pipeline = macore_client.pipeline:main