kiapi 0.1.0__py3-none-any.whl

kiapi/cli/check/_helpers/check_web_web_search.py

@@ -0,0 +1,14 @@
+from kiapi.capabilities.web import SearchRequest, handle_search
+from kiapi.core.app import AppContext
+from kiapi.core.model import ModelSpec
+
+from .._operations.build_check_result import build_check_result
+from .._schemas.check_result import CheckResult
+
+
+def check(ctx: AppContext, spec: ModelSpec) -> CheckResult:
+    result, artifacts = handle_search(
+        ctx,
+        SearchRequest(query="kiapi", max_results=1),
+    )
+    return build_check_result(spec, result, artifacts)

kiapi/cli/check/_operations/build_check_result.py

@@ -0,0 +1,20 @@
+from typing import Any
+
+from kiapi.core.file import FileID
+from kiapi.core.model import ModelSpec
+
+from .._schemas.check_result import CheckResult
+
+
+def build_check_result(
+    spec: ModelSpec,
+    result: dict[str, Any],
+    artifacts: list[FileID],
+) -> CheckResult:
+    artifact_label = f", artifacts={len(artifacts)}" if artifacts else ""
+    return CheckResult(
+        ok=True,
+        message=f"{spec.domain}/{spec.family}/{spec.name} ok{artifact_label}",
+        artifacts=artifacts,
+        result=result,
+    )

kiapi/cli/check/_operations/check_context.py

@@ -0,0 +1,10 @@
+from typing import Protocol
+
+from kiapi.core.app import AppContext
+from kiapi.core.model import ModelSpec
+
+from .._schemas.check_result import CheckResult
+
+
+class CheckOperation(Protocol):
+    def __call__(self, ctx: AppContext, spec: ModelSpec) -> CheckResult: ...

kiapi/cli/check/_operations/create_sample_image.py

@@ -0,0 +1,46 @@
+from io import BytesIO
+
+from PIL import Image, ImageDraw
+
+from kiapi.core.app import AppContext
+
+
+def create_sample_image(ctx: AppContext, *, size: int = 256) -> str:
+    image = Image.new("RGB", (size, size), (245, 245, 238))
+    draw = ImageDraw.Draw(image)
+    margin = max(size // 8, 8)
+    stroke = max(size // 32, 2)
+    draw.rectangle(
+        (margin, margin, size - margin, size - margin),
+        outline=(40, 80, 160),
+        width=stroke,
+    )
+    draw.ellipse(
+        (
+            int(size * 0.3),
+            int(size * 0.28),
+            int(size * 0.7),
+            int(size * 0.66),
+        ),
+        fill=(240, 196, 76),
+    )
+    draw.line(
+        (
+            int(size * 0.2),
+            int(size * 0.75),
+            int(size * 0.8),
+            int(size * 0.75),
+        ),
+        fill=(36, 120, 88),
+        width=stroke,
+    )
+
+    out = BytesIO()
+    image.save(out, format="PNG")
+    rec = ctx.file_store.put_bytes(
+        out.getvalue(),
+        filename="kiapi_check_input.png",
+        content_type="image/png",
+        meta={"kind": "check_input"},
+    )
+    return rec.file_id

kiapi/cli/check/_schemas/check_result.py

@@ -0,0 +1,12 @@
+from dataclasses import dataclass, field
+from typing import Any
+
+from kiapi.core.file import FileID
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    ok: bool
+    message: str
+    artifacts: list[FileID] = field(default_factory=list)
+    result: dict[str, Any] = field(default_factory=dict)

kiapi/cli/check/cli.py

@@ -0,0 +1,89 @@
+import importlib
+import re
+import traceback
+
+import click
+
+from kiapi.cli import register_all_capabilities, select_specs
+from kiapi.core.app import AppContext
+from kiapi.core.model import ModelSpec
+
+from ._operations.check_context import CheckOperation
+from ._schemas.check_result import CheckResult
+
+_NON_IDENTIFIER = re.compile(r"[^0-9a-zA-Z]+")
+
+
+@click.command()
+@click.option("--all", "check_all", is_flag=True, help="Check all models")
+@click.option("--domain", "domains", multiple=True, help="Check domain")
+@click.option("--family", "families", multiple=True, help="Check family")
+@click.option("--repo", "repos", multiple=True, help="Check repo/image")
+def check(
+    check_all: bool,
+    domains: tuple[str, ...],
+    families: tuple[str, ...],
+    repos: tuple[str, ...],
+) -> None:
+    """Run lightweight smoke checks for activated models."""
+    register_all_capabilities()
+    specs = select_specs(
+        all_selected=check_all,
+        domains=domains,
+        families=families,
+        repos=repos,
+        interactive=True,
+        action="check",
+    )
+
+    ctx = AppContext.create()
+    failures = 0
+    try:
+        for spec in specs:
+            click.echo(f"checking {spec.domain}/{spec.family}/{spec.name} ...")
+            result = _run_check(ctx, spec)
+            mark = "ok" if result.ok else "failed"
+            click.echo(f"  [{mark}] {result.message}")
+            failures += 0 if result.ok else 1
+    finally:
+        ctx.memory_manager.shutdown()
+
+    if failures:
+        raise click.ClickException(f"{failures} check(s) failed.")
+
+
+def _run_check(ctx: AppContext, spec: ModelSpec) -> CheckResult:
+    try:
+        check_operation = _resolve_check_operation(spec)
+    except ModuleNotFoundError:
+        return CheckResult(
+            ok=False,
+            message=f"{spec.domain}/{spec.family}/{spec.name}: check is not implemented",
+        )
+
+    try:
+        return check_operation(ctx, spec)
+    except Exception as exc:
+        traceback.print_exc()
+        return CheckResult(
+            ok=False,
+            message=f"{spec.domain}/{spec.family}/{spec.name}: {exc}",
+        )
+
+
+def _resolve_check_operation(spec: ModelSpec) -> CheckOperation:
+    module_name = _module_name(spec)
+    module = importlib.import_module(
+        f"kiapi.cli.check._helpers.{module_name}",
+    )
+    check_operation = module.check
+    return check_operation  # type: ignore[no-any-return]
+
+
+def _module_name(spec: ModelSpec) -> str:
+    parts = ("check", spec.domain, spec.family, spec.name)
+    return "_".join(_slug(part) for part in parts)
+
+
+def _slug(value: str) -> str:
+    return _NON_IDENTIFIER.sub("_", value.strip().lower()).strip("_")

kiapi/cli/cli.py

@@ -0,0 +1,29 @@
+import click
+
+from kiapi.core.config import UserConfigError, load_user_settings
+
+from .activate.cli import activate
+from .check.cli import check
+from .config.cli import config_cli
+from .deactivate.cli import deactivate
+from .run.cli import run
+from .service.cli import service
+from .status.cli import status
+
+
+@click.group()
+def main() -> None:
+    """kiapi command line interface."""
+    try:
+        load_user_settings()
+    except UserConfigError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+
+main.add_command(run)
+main.add_command(status)
+main.add_command(activate)
+main.add_command(deactivate)
+main.add_command(check)
+main.add_command(config_cli)
+main.add_command(service)

kiapi/cli/config/cli.py

@@ -0,0 +1,17 @@
+import click
+
+from .edit.cli import edit
+from .init.cli import init
+from .show.cli import show
+from .template.cli import template
+
+
+@click.group(name="config")
+def config_cli() -> None:
+    """Manage kiapi user settings."""
+
+
+config_cli.add_command(init)
+config_cli.add_command(show)
+config_cli.add_command(edit)
+config_cli.add_command(template)

kiapi/cli/config/edit/cli.py

@@ -0,0 +1,32 @@
+import os
+import shlex
+import subprocess
+
+import click
+
+from kiapi.core.config import get_user_settings_path
+
+
+@click.command(name="edit")
+def edit() -> None:
+    """Open the user settings file in an editor."""
+    path = get_user_settings_path()
+    if not path.exists():
+        raise click.ClickException(
+            f"Settings file does not exist: {path}\n"
+            "Run `kiapi config init` to create it."
+        )
+
+    command = _resolve_editor_command(str(path))
+    subprocess.run(command, check=True)
+
+
+def _resolve_editor_command(path: str) -> list[str]:
+    editor = os.getenv("VISUAL") or os.getenv("EDITOR")
+    if editor:
+        return [*shlex.split(editor), path]
+
+    if os.name == "posix":
+        return ["open", "-t", path]
+
+    return ["notepad", path]

kiapi/cli/config/init/cli.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+import click
+
+from kiapi.core.config import get_user_settings_path
+
+_DEFAULT_USER_SETTINGS = """# kiapi user settings
+kiapi.api:
+  host: 127.0.0.1
+  port: 8000
+  auth_token: null
+
+kiapi.core.memory:
+  memory_limit_gb: null
+  default_ttl_s: 1800.0
+"""
+
+
+@click.command(name="init")
+def init() -> None:
+    """Create the user settings file if it does not exist."""
+    path = _init_user_settings()
+    click.echo(str(path))
+
+
+def _init_user_settings() -> Path:
+    path = get_user_settings_path()
+    if path.exists():
+        return path
+
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(_DEFAULT_USER_SETTINGS, encoding="utf-8")
+    return path

kiapi/cli/config/show/cli.py

@@ -0,0 +1,13 @@
+import click
+
+from kiapi.core.config import get_user_settings_path
+
+
+@click.command(name="show")
+def show() -> None:
+    """Show the user settings file."""
+    path = get_user_settings_path()
+    if not path.exists():
+        raise click.ClickException(f"Settings file does not exist: {path}")
+
+    click.echo(path.read_text(encoding="utf-8"), nl=False)

kiapi/cli/config/template/cli.py

@@ -0,0 +1,36 @@
+import click
+from pydantic_settings_manager import generate_user_configs_yaml
+
+_SETTINGS_IMPORT_PATHS = [
+    "kiapi.api",
+    "kiapi.core.logging",
+    "kiapi.core.app",
+    "kiapi.core.workdir",
+    "kiapi.core.file",
+    "kiapi.core.memory",
+    "kiapi.core.worker",
+    "kiapi.core.net",
+    "kiapi.capabilities.chat",
+    "kiapi.capabilities.embedding",
+    "kiapi.capabilities.depthpro",
+    "kiapi.capabilities.ernie",
+    "kiapi.capabilities.flux2",
+    "kiapi.capabilities.ideogram4",
+    "kiapi.capabilities.qwen",
+    "kiapi.capabilities.seedvr2",
+    "kiapi.capabilities.zimage",
+    "kiapi.capabilities.acestep",
+    "kiapi.capabilities.audiogen",
+    "kiapi.capabilities.ltx2",
+    "kiapi.capabilities.web",
+]
+
+
+@click.command(name="template")
+def template() -> None:
+    """Show the full user settings template."""
+    click.echo(_generate_user_settings_template())
+
+
+def _generate_user_settings_template() -> str:
+    return generate_user_configs_yaml(_SETTINGS_IMPORT_PATHS)

kiapi/cli/deactivate/cli.py

@@ -0,0 +1,49 @@
+import click
+import questionary
+
+from kiapi.cli import (
+    dedupe_resources,
+    register_all_capabilities,
+    run_resources,
+    select_specs,
+)
+from kiapi.core.setup import SetupManager, SetupResource
+
+
+@click.command()
+@click.option("--all", "deactivate_all", is_flag=True, help="Deactivate all models")
+@click.option("--domain", "domains", multiple=True, help="Deactivate domain")
+@click.option("--family", "families", multiple=True, help="Deactivate family")
+@click.option("--repo", "repos", multiple=True, help="Deactivate repo/image")
+def deactivate(
+    deactivate_all: bool,
+    domains: tuple[str, ...],
+    families: tuple[str, ...],
+    repos: tuple[str, ...],
+) -> None:
+    """Select and remove Hugging Face snapshots, Docker images, and URL files."""
+    register_all_capabilities()
+    specs = select_specs(
+        all_selected=deactivate_all,
+        domains=domains,
+        families=families,
+        repos=repos,
+        interactive=True,
+        action="deactivate",
+    )
+    resources = dedupe_resources(specs)
+    if not _confirm_deactivate(resources):
+        click.echo("Canceled.")
+        return
+    run_resources("deactivate", resources, SetupManager())
+
+
+def _confirm_deactivate(resources: list[SetupResource]) -> bool:
+    if not resources:
+        return True
+    labels = ", ".join(resource.label for resource in resources)
+    answer = questionary.confirm(
+        f"Deactivate {len(resources)} setup resource(s)? {labels}",
+        default=False,
+    ).ask()
+    return bool(answer)

kiapi/cli/run/asgi.py

@@ -0,0 +1,16 @@
+from fastapi import FastAPI
+
+from kiapi.cli import register_all_capabilities
+
+
+def create_app() -> FastAPI:
+    """ASGI factory for uvicorn (used by hot reload).
+
+    The reload subprocess re-imports the app fresh, so capability
+    registration must run here rather than only in the `kiapi run` CLI.
+    """
+    register_all_capabilities()
+
+    from kiapi.api.app import app
+
+    return app

kiapi/cli/run/cli.py

@@ -0,0 +1,59 @@
+import os
+
+import click
+import uvicorn
+
+from kiapi.api import settings_manager as api_settings_manager
+from kiapi.cli import register_all_capabilities
+from kiapi.core.logging import get_log_level
+from kiapi.core.logging import settings_manager as logging_settings_manager
+
+
+@click.command()
+@click.option("--host", type=str, help="Bind socket to this host")
+@click.option("--port", type=int, help="Bind socket to this port")
+@click.option("--debug", is_flag=True, help="Enable debug logging and hot reload")
+def run(host: str | None, port: int | None, debug: bool) -> None:
+    """Run the kiapi API server."""
+    api_cli_args: dict[str, str | int] = {}
+
+    if host is not None:
+        api_cli_args["host"] = host
+    if port is not None:
+        api_cli_args["port"] = port
+
+    if api_cli_args:
+        api_settings_manager.cli_args = api_cli_args
+
+    settings = api_settings_manager.get_settings()
+
+    if debug:
+        logging_settings_manager.cli_args = {"log_level": "DEBUG"}
+        # The reload subprocess re-imports the app fresh and does not inherit
+        # in-process cli_args, so propagate the log level via the environment.
+        os.environ["KIAPI_LOG_LEVEL"] = "DEBUG"
+
+        # Hot reload requires an import string (the worker subprocess
+        # re-imports the app), so use the ASGI factory that registers
+        # capabilities on import.
+        uvicorn.run(
+            "kiapi.cli.run.asgi:create_app",
+            factory=True,
+            reload=True,
+            reload_dirs=["kiapi"],
+            host=settings.host,
+            port=settings.port,
+            log_level=get_log_level(),
+        )
+        return
+
+    register_all_capabilities()
+
+    from kiapi.api.app import app
+
+    uvicorn.run(
+        app,
+        host=settings.host,
+        port=settings.port,
+        log_level=get_log_level(),
+    )

kiapi/cli/service/__init__.py

@@ -0,0 +1,5 @@
+from ._services import service_manager
+
+__all__ = [
+    "service_manager",
+]

kiapi/cli/service/_services/service_manager.py

@@ -0,0 +1,107 @@
+import os
+import plistlib
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+SERVICE_LABEL = os.getenv("KIAPI_SERVICE_LABEL", "io.github.kiarina.kiapi")
+
+
+def get_launchd_domain() -> str:
+    return f"gui/{os.getuid()}"
+
+
+def get_plist_path() -> Path:
+    return Path.home() / "Library" / "LaunchAgents" / f"{SERVICE_LABEL}.plist"
+
+
+def get_log_dir() -> Path:
+    return Path("/tmp/kiapi/service")
+
+
+def get_stdout_path() -> Path:
+    return get_log_dir() / "out.log"
+
+
+def get_stderr_path() -> Path:
+    return get_log_dir() / "err.log"
+
+
+def is_installed() -> bool:
+    return get_plist_path().exists()
+
+
+def is_loaded() -> bool:
+    result = run_launchctl(["print", f"{get_launchd_domain()}/{SERVICE_LABEL}"])
+    return result.returncode == 0
+
+
+def install() -> None:
+    get_log_dir().mkdir(parents=True, exist_ok=True)
+    plist_path = get_plist_path()
+    plist_path.parent.mkdir(parents=True, exist_ok=True)
+
+    plist = {
+        "Label": SERVICE_LABEL,
+        "ProgramArguments": [
+            sys.executable,
+            "-m",
+            "kiapi",
+            "run",
+        ],
+        "EnvironmentVariables": {
+            "PYTHONUNBUFFERED": "1",
+        },
+        "RunAtLoad": True,
+        "KeepAlive": True,
+        "StandardOutPath": str(get_stdout_path()),
+        "StandardErrorPath": str(get_stderr_path()),
+    }
+    plist_path.write_bytes(plistlib.dumps(plist, sort_keys=False))
+
+
+def start() -> None:
+    domain = get_launchd_domain()
+    result = run_launchctl(["bootstrap", domain, str(get_plist_path())])
+    if result.returncode != 0:
+        raise RuntimeError(_format_launchctl_error(result.stderr))
+
+    result = run_launchctl(["kickstart", "-k", f"{domain}/{SERVICE_LABEL}"])
+    if result.returncode != 0:
+        raise RuntimeError(_format_launchctl_error(result.stderr))
+
+
+def stop() -> None:
+    result = run_launchctl(["bootout", f"{get_launchd_domain()}/{SERVICE_LABEL}"])
+    if result.returncode != 0:
+        raise RuntimeError(_format_launchctl_error(result.stderr))
+
+    _wait_until_stopped()
+
+
+def uninstall() -> None:
+    get_plist_path().unlink()
+
+
+def run_launchctl(args: list[str]) -> subprocess.CompletedProcess[str]:
+    return subprocess.run(
+        ["launchctl", *args],
+        check=False,
+        capture_output=True,
+        text=True,
+    )
+
+
+def _wait_until_stopped() -> None:
+    for _ in range(20):
+        if not is_loaded():
+            return
+        time.sleep(0.1)
+
+
+def _format_launchctl_error(stderr: str) -> str:
+    detail = stderr.strip()
+    if not detail:
+        return "launchctl failed"
+    return detail

kiapi/cli/service/cli.py

@@ -0,0 +1,19 @@
+import click
+
+from .install.cli import install
+from .start.cli import start
+from .status.cli import status
+from .stop.cli import stop
+from .uninstall.cli import uninstall
+
+
+@click.group(name="service")
+def service() -> None:
+    """Manage the kiapi launchd user service."""
+
+
+service.add_command(install)
+service.add_command(start)
+service.add_command(stop)
+service.add_command(status)
+service.add_command(uninstall)

kiapi/cli/service/install/cli.py

@@ -0,0 +1,17 @@
+import click
+
+from kiapi.cli.service import service_manager
+
+
+@click.command(name="install")
+def install() -> None:
+    """Install the kiapi launchd user service."""
+    plist_path = service_manager.get_plist_path()
+    if service_manager.is_installed():
+        raise click.ClickException(f"Service is already installed: {plist_path}")
+
+    service_manager.install()
+    click.echo(f"Installed {service_manager.SERVICE_LABEL}")
+    click.echo(f"Plist: {plist_path}")
+    click.echo(f"stdout: {service_manager.get_stdout_path()}")
+    click.echo(f"stderr: {service_manager.get_stderr_path()}")

kiapi/cli/service/start/cli.py

@@ -0,0 +1,22 @@
+import click
+
+from kiapi.cli.service import service_manager
+
+
+@click.command(name="start")
+def start() -> None:
+    """Start the kiapi launchd user service."""
+    plist_path = service_manager.get_plist_path()
+    if not service_manager.is_installed():
+        raise click.ClickException(f"Service is not installed: {plist_path}")
+    if service_manager.is_loaded():
+        raise click.ClickException(
+            f"Service is already started: {service_manager.SERVICE_LABEL}"
+        )
+
+    try:
+        service_manager.start()
+    except RuntimeError as exc:
+        raise click.ClickException(str(exc)) from exc
+
+    click.echo(f"Started {service_manager.SERVICE_LABEL}")