caasi 0.1.0__py3-none-any.whl

caasi/__init__.py

@@ -0,0 +1,7 @@
+"""Caasi — a lightweight, CLI-first orchestration layer for the robotics ecosystem.
+
+Headless-first, CLI-first, process-oriented, and visualization-independent.
+Independent open-source project; not affiliated with or endorsed by NVIDIA.
+"""
+
+__version__ = "0.1.0"

caasi/checks/__init__.py

@@ -0,0 +1,96 @@
+"""Doctor check engine.
+
+Checks are grouped into sections. Each check module registers callables that
+receive a :class:`CheckContext` and return :class:`CheckResult` objects. All
+external probes are subprocess/metadata based — the CLI never imports heavy
+robotics libraries.
+"""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+from typing import TYPE_CHECKING, Any, Callable, Literal
+
+if TYPE_CHECKING:  # pragma: no cover
+    from ..core.config import Config
+
+Status = Literal["ok", "warn", "fail", "skip"]
+
+
+@dataclass(frozen=True)
+class CheckResult:
+    section: str
+    name: str
+    status: Status
+    detail: str = ""
+    hint: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+@dataclass
+class CheckContext:
+    config: "Config"
+
+
+CheckFn = Callable[[CheckContext], list[CheckResult]]
+
+# Ordered section keys; titles are resolved through i18n at render time.
+SECTION_KEYS: list[str] = [
+    "system",
+    "hardware",
+    "nvidia",
+    "graphics",
+    "python",
+    "isaac",
+    "ros",
+    "robotics",
+    "ml",
+    "vision",
+    "simulators",
+    "containers",
+    "storage",
+]
+
+_REGISTRY: dict[str, list[CheckFn]] = {}
+
+
+def register(section: str) -> Callable[[CheckFn], CheckFn]:
+    def decorator(fn: CheckFn) -> CheckFn:
+        _REGISTRY.setdefault(section, []).append(fn)
+        return fn
+
+    return decorator
+
+
+def run_checks(
+    sections: list[str] | None = None, config: "Config | None" = None
+) -> list[CheckResult]:
+    import_all_check_modules()
+    from ..state import cfg as state_cfg
+
+    ctx = CheckContext(config=config or state_cfg())
+    results: list[CheckResult] = []
+    for key in sections or SECTION_KEYS:
+        for fn in _REGISTRY.get(key, []):
+            results.extend(fn(ctx))
+    return results
+
+
+def import_all_check_modules() -> None:
+    from . import (  # noqa: F401
+        containers,
+        graphics,
+        hardware,
+        isaac,
+        ml,
+        nvidia,
+        python_env,
+        robotics,
+        ros,
+        simulators,
+        storage,
+        system,
+        vision,
+    )

caasi/checks/containers.py

@@ -0,0 +1,35 @@
+"""Container runtime checks: docker, podman."""
+
+from __future__ import annotations
+
+from ..i18n import _
+from ..utils import shell
+from . import CheckResult, register
+
+
+def _probe(name: str, binary: str, name_key: str) -> CheckResult:
+    path = shell.which(binary)
+    if not path:
+        return CheckResult(name, _(name_key), "skip", _("doctor.containers.not_installed"))
+    result = shell.run_cmd([binary, "--version"], timeout=5)
+    if result.ok:
+        return CheckResult(name, _(name_key), "ok", result.stdout.strip().splitlines()[0])
+    return CheckResult(name, _(name_key), "warn", result.stderr.strip() or _("doctor.containers.error"))
+
+
+@register("containers")
+def check_containers(ctx) -> list[CheckResult]:
+    docker = _probe("containers", "docker", "doctor.containers.docker")
+    podman = _probe("containers", "podman", "doctor.containers.podman")
+    results = [docker, podman]
+    if docker.status == "skip" and podman.status == "skip":
+        results.append(
+            CheckResult(
+                "containers",
+                _("doctor.containers.title"),
+                "warn",
+                _("doctor.containers.none"),
+                _("doctor.containers.hint"),
+            )
+        )
+    return results

caasi/checks/graphics.py

@@ -0,0 +1,50 @@
+"""Graphics checks: Vulkan availability, display server."""
+
+from __future__ import annotations
+
+import os
+
+from ..i18n import _
+from ..utils import shell
+from . import CheckResult, register
+
+
+@register("graphics")
+def check_graphics(ctx) -> list[CheckResult]:
+    results: list[CheckResult] = []
+
+    if shell.which("vulkaninfo"):
+        results.append(CheckResult("graphics", _("doctor.graphics.vulkan"), "ok", "vulkaninfo"))
+    else:
+        ld = shell.run_cmd(["ldconfig", "-p"], timeout=5)
+        if ld.ok and "libvulkan" in ld.stdout:
+            results.append(
+                CheckResult(
+                    "graphics", _("doctor.graphics.vulkan"), "ok", _("doctor.graphics.vulkan_lib")
+                )
+            )
+        else:
+            results.append(
+                CheckResult(
+                    "graphics",
+                    _("doctor.graphics.vulkan"),
+                    "warn",
+                    _("doctor.graphics.vulkan_missing"),
+                    _("doctor.graphics.vulkan_hint"),
+                )
+            )
+
+    if os.environ.get("WAYLAND_DISPLAY") or os.environ.get("DISPLAY"):
+        results.append(
+            CheckResult("graphics", _("doctor.graphics.display"), "ok", _("doctor.graphics.display_on"))
+        )
+    else:
+        results.append(
+            CheckResult(
+                "graphics",
+                _("doctor.graphics.display"),
+                "skip",
+                _("doctor.graphics.display_off"),
+            )
+        )
+    return results

caasi/checks/hardware.py

@@ -0,0 +1,47 @@
+"""Hardware checks: CPU, RAM."""
+
+from __future__ import annotations
+
+import os
+
+from ..i18n import _
+from ..utils import sysinfo
+from . import CheckResult, register
+
+RAM_WARN_KIB = 16 * 1024 * 1024  # below 16 GiB is tight for Isaac workflows
+
+
+@register("hardware")
+def check_hardware(ctx) -> list[CheckResult]:
+    results: list[CheckResult] = []
+
+    model = sysinfo.cpu_model()
+    cores = os.cpu_count()
+    if model or cores:
+        detail = ", ".join(part for part in (model, f"{cores} cores") if part)
+        results.append(CheckResult("hardware", _("doctor.hardware.cpu"), "ok", detail))
+    else:
+        results.append(
+            CheckResult(
+                "hardware", _("doctor.hardware.cpu"), "warn", "", _("doctor.hardware.cpu_hint")
+            )
+        )
+
+    meminfo = sysinfo.read_meminfo()
+    total_kib = meminfo.get("MemTotal")
+    available_kib = meminfo.get("MemAvailable")
+    if total_kib:
+        detail = _("doctor.hardware.ram_detail").format(
+            total=total_kib / (1024 * 1024),
+            available=(available_kib or 0) / (1024 * 1024),
+        )
+        status = "ok" if total_kib >= RAM_WARN_KIB else "warn"
+        hint = "" if status == "ok" else _("doctor.hardware.ram_hint")
+        results.append(CheckResult("hardware", _("doctor.hardware.ram"), status, detail, hint))
+    else:
+        results.append(
+            CheckResult(
+                "hardware", _("doctor.hardware.ram"), "warn", "", _("doctor.hardware.ram_hint")
+            )
+        )
+    return results

caasi/checks/isaac.py

@@ -0,0 +1,99 @@
+"""Isaac Sim / Isaac Lab detection.
+
+Detection order per tool: configured tool registry -> environment variables
+-> common install locations -> pip metadata. Reused by `caasi info`.
+"""
+
+from __future__ import annotations
+
+import glob
+import os
+from pathlib import Path
+
+from ..core.config import Config
+from ..i18n import _
+from ..utils import pydist
+from . import CheckResult, register
+
+Detection = tuple[str, str, str]  # (status, detail, hint)
+
+
+def _glob_first(patterns: list[str]) -> str | None:
+    for pattern in patterns:
+        matches = sorted(glob.glob(os.path.expanduser(pattern)))
+        if matches:
+            return matches[-1]
+    return None
+
+
+def detect_isaac_sim(config: Config) -> Detection:
+    tool = config.resolve_tool("isaacsim")
+    if tool is not None:
+        path = tool.expanded_path
+        if path is not None and path.exists():
+            label = f" {tool.version}" if tool.version else ""
+            return "ok", _("doctor.isaac.sim_found").format(version=label, path=str(path)), ""
+        return (
+            "warn",
+            _("doctor.isaac.sim_configured_missing").format(path=tool.path or "?"),
+            _("doctor.isaac.config_hint"),
+        )
+
+    env_path = os.environ.get("ISAACSIM_PATH")
+    if env_path and Path(env_path).expanduser().exists():
+        return "ok", _("doctor.isaac.sim_found").format(version="", path=env_path), ""
+
+    common = _glob_first(
+        [
+            "~/isaacsim",
+            "~/.local/share/ov/pkg/isaac-sim-*",
+            "~/.local/share/ov/pkg/isaac_sim-*",
+            "/opt/isaac-sim*",
+            "/opt/isaacsim*",
+        ]
+    )
+    if common:
+        return "ok", _("doctor.isaac.sim_found").format(version="", path=common), ""
+
+    version = pydist.pip_version("isaacsim")
+    if version:
+        return "ok", _("doctor.isaac.sim_pip").format(version=version), ""
+
+    return "fail", _("doctor.isaac.sim_missing"), _("doctor.isaac.sim_hint")
+
+
+def detect_isaac_lab(config: Config) -> Detection:
+    tool = config.resolve_tool("isaaclab")
+    if tool is not None:
+        path = tool.expanded_path
+        if path is not None and path.exists():
+            label = f" {tool.version}" if tool.version else ""
+            return "ok", _("doctor.isaac.lab_found").format(version=label, path=str(path)), ""
+        return (
+            "warn",
+            _("doctor.isaac.lab_configured_missing").format(path=tool.path or "?"),
+            _("doctor.isaac.config_hint"),
+        )
+
+    env_path = os.environ.get("ISAACLAB_PATH")
+    if env_path and Path(env_path).expanduser().exists():
+        return "ok", _("doctor.isaac.lab_found").format(version="", path=env_path), ""
+
+    common = _glob_first(["~/isaaclab", "~/IsaacLab", "~/workspace/isaaclab", "~/workspace/IsaacLab"])
+    if common:
+        return "ok", _("doctor.isaac.lab_found").format(version="", path=common), ""
+
+    version = pydist.pip_version("isaaclab")
+    if version:
+        return "ok", _("doctor.isaac.lab_pip").format(version=version), ""
+
+    return "fail", _("doctor.isaac.lab_missing"), _("doctor.isaac.lab_hint")
+
+
+@register("isaac")
+def check_isaac(ctx) -> list[CheckResult]:
+    status, detail, hint = detect_isaac_sim(ctx.config)
+    results = [CheckResult("isaac", _("doctor.isaac.sim"), status, detail, hint)]
+    status, detail, hint = detect_isaac_lab(ctx.config)
+    results.append(CheckResult("isaac", _("doctor.isaac.lab"), status, detail, hint))
+    return results

caasi/checks/ml.py

@@ -0,0 +1,42 @@
+"""ML stack checks: PyTorch, TensorRT, ONNX Runtime, cuDNN (metadata only)."""
+
+from __future__ import annotations
+
+from ..i18n import _
+from ..utils import pydist, shell
+from . import CheckResult, register
+
+
+def _pip_check(section: str, name_key: str, dists: tuple[str, ...], hint_key: str) -> CheckResult:
+    version = pydist.pip_version(*dists)
+    if version:
+        return CheckResult(section, _(name_key), "ok", version)
+    return CheckResult(section, _(name_key), "fail", _("doctor.ml.not_installed"), _(hint_key))
+
+
+@register("ml")
+def check_ml(ctx) -> list[CheckResult]:
+    results = [
+        _pip_check("ml", "doctor.ml.torch", ("torch",), "doctor.ml.torch_hint"),
+        _pip_check("ml", "doctor.ml.tensorrt", ("tensorrt", "tensorrt_libs"), "doctor.ml.tensorrt_hint"),
+        _pip_check(
+            "ml", "doctor.ml.onnx", ("onnxruntime-gpu", "onnxruntime"), "doctor.ml.onnx_hint"
+        ),
+    ]
+
+    cudnn = pydist.pip_version("nvidia-cudnn-cu12", "nvidia-cudnn-cu11")
+    if cudnn:
+        results.append(CheckResult("ml", _("doctor.ml.cudnn"), "ok", cudnn))
+    else:
+        ld = shell.run_cmd(["ldconfig", "-p"], timeout=5)
+        if ld.ok and "libcudnn" in ld.stdout:
+            results.append(
+                CheckResult("ml", _("doctor.ml.cudnn"), "ok", _("doctor.ml.cudnn_system"))
+            )
+        else:
+            results.append(
+                CheckResult(
+                    "ml", _("doctor.ml.cudnn"), "warn", _("doctor.ml.not_installed"), _("doctor.ml.cudnn_hint")
+                )
+            )
+    return results

caasi/checks/nvidia.py

@@ -0,0 +1,70 @@
+"""NVIDIA checks: driver, GPUs, CUDA (via nvidia-smi)."""
+
+from __future__ import annotations
+
+from ..core import nvidia
+from ..i18n import _
+from . import CheckResult, register
+
+
+@register("nvidia")
+def check_nvidia(ctx) -> list[CheckResult]:
+    if not nvidia.available():
+        return [
+            CheckResult(
+                "nvidia",
+                _("doctor.nvidia.smi"),
+                "fail",
+                _("doctor.nvidia.smi_missing_detail"),
+                _("doctor.nvidia.smi_hint"),
+            )
+        ]
+
+    results: list[CheckResult] = []
+    try:
+        gpus = nvidia.query(["index", "name", "memory.total", "driver_version"])
+    except nvidia.NvidiaSmiError as exc:
+        return [
+            CheckResult(
+                "nvidia",
+                _("doctor.nvidia.smi"),
+                "fail",
+                str(exc),
+                _("doctor.nvidia.smi_hint"),
+            )
+        ]
+
+    driver = gpus[0].get("driver_version") if gpus else None
+    results.append(
+        CheckResult(
+            "nvidia",
+            _("doctor.nvidia.driver"),
+            "ok",
+            _("doctor.nvidia.driver_detail").format(driver=driver or "?"),
+        )
+    )
+    for gpu in gpus:
+        vram = gpu.get("memory.total")
+        detail = _("doctor.nvidia.gpu_detail").format(
+            name=gpu.get("name", "?"),
+            vram=f"{vram / 1024:.1f} GiB" if isinstance(vram, (int, float)) else "?",
+        )
+        results.append(CheckResult("nvidia", _("doctor.nvidia.gpu"), "ok", detail))
+
+    cuda = nvidia.cuda_version()
+    if cuda:
+        results.append(
+            CheckResult(
+                "nvidia",
+                _("doctor.nvidia.cuda"),
+                "ok",
+                _("doctor.nvidia.cuda_detail").format(version=cuda),
+            )
+        )
+    else:
+        results.append(
+            CheckResult(
+                "nvidia", _("doctor.nvidia.cuda"), "warn", "", _("doctor.nvidia.cuda_hint")
+            )
+        )
+    return results

caasi/checks/python_env.py

@@ -0,0 +1,51 @@
+"""Python environment checks."""
+
+from __future__ import annotations
+
+import os
+import platform
+import sys
+
+from ..i18n import _
+from . import CheckResult, register
+
+MINIMUM = (3, 10)
+
+
+@register("python")
+def check_python(ctx) -> list[CheckResult]:
+    results: list[CheckResult] = []
+    version = platform.python_version()
+    if sys.version_info[:2] >= MINIMUM:
+        results.append(
+            CheckResult(
+                "python", _("doctor.python.version"), "ok", f"Python {version} ({sys.executable})"
+            )
+        )
+    else:
+        results.append(
+            CheckResult(
+                "python",
+                _("doctor.python.version"),
+                "fail",
+                f"Python {version}",
+                _("doctor.python.version_hint"),
+            )
+        )
+
+    conda_env = os.environ.get("CONDA_DEFAULT_ENV")
+    if conda_env:
+        results.append(
+            CheckResult(
+                "python", _("doctor.python.env"), "ok", _("doctor.python.conda").format(env=conda_env)
+            )
+        )
+    elif sys.prefix != sys.base_prefix:
+        results.append(
+            CheckResult("python", _("doctor.python.env"), "ok", _("doctor.python.venv"))
+        )
+    else:
+        results.append(
+            CheckResult("python", _("doctor.python.env"), "skip", _("doctor.python.system_env"))
+        )
+    return results

caasi/checks/robotics.py

@@ -0,0 +1,54 @@
+"""Robotics stack checks: Nav2, MoveIt 2, ros2_control (best-effort via ros2 CLI)."""
+
+from __future__ import annotations
+
+from ..core import ros as ros_core
+from ..i18n import _
+from ..utils import shell
+from . import CheckResult, register
+
+STACKS = [
+    ("nav2", "nav2_bringup", "doctor.robotics.nav2"),
+    ("moveit2", "moveit_core", "doctor.robotics.moveit"),
+    ("ros2_control", "controller_manager", "doctor.robotics.control"),
+]
+
+PKG_TIMEOUT = 8.0
+
+
+@register("robotics")
+def check_robotics(ctx) -> list[CheckResult]:
+    ros2 = ros_core.find_ros2_binary()
+    if not ros2:
+        return [
+            CheckResult(
+                "robotics",
+                _("doctor.robotics.title"),
+                "skip",
+                _("doctor.robotics.no_ros2"),
+                _("doctor.robotics.no_ros2_hint"),
+            )
+        ]
+
+    results: list[CheckResult] = []
+    for stack, package, name_key in STACKS:
+        probe = shell.run_cmd([ros2, "pkg", "prefix", package], timeout=PKG_TIMEOUT)
+        if probe.ok:
+            results.append(CheckResult("robotics", _(name_key), "ok", package))
+        elif probe.returncode == -1:
+            results.append(
+                CheckResult(
+                    "robotics", _(name_key), "warn", _("doctor.robotics.timeout").format(package=package)
+                )
+            )
+        else:
+            results.append(
+                CheckResult(
+                    "robotics",
+                    _(name_key),
+                    "fail",
+                    _("doctor.robotics.not_installed").format(package=package),
+                    _("doctor.robotics.hint").format(stack=stack),
+                )
+            )
+    return results

caasi/checks/ros.py

@@ -0,0 +1,63 @@
+"""ROS 2 checks: distro, setup file, ros2 CLI, middleware."""
+
+from __future__ import annotations
+
+import os
+
+from ..core import ros as ros_core
+from ..i18n import _
+from . import CheckResult, register
+
+
+@register("ros")
+def check_ros(ctx) -> list[CheckResult]:
+    distro, root = ros_core.find_distro()
+    if distro is None:
+        return [
+            CheckResult(
+                "ros",
+                _("doctor.ros.distro"),
+                "fail",
+                _("doctor.ros.missing"),
+                _("doctor.ros.hint"),
+            )
+        ]
+
+    results: list[CheckResult] = []
+    results.append(CheckResult("ros", _("doctor.ros.distro"), "ok", distro))
+
+    if root is not None and (root / "setup.bash").exists():
+        results.append(
+            CheckResult(
+                "ros", _("doctor.ros.setup"), "ok", str(root / "setup.bash")
+            )
+        )
+    else:
+        results.append(
+            CheckResult(
+                "ros",
+                _("doctor.ros.setup"),
+                "warn",
+                _("doctor.ros.setup_missing").format(distro=distro),
+                _("doctor.ros.setup_hint"),
+            )
+        )
+
+    ros2 = ros_core.find_ros2_binary()
+    if ros2:
+        results.append(CheckResult("ros", _("doctor.ros.cli"), "ok", ros2))
+    else:
+        results.append(
+            CheckResult(
+                "ros", _("doctor.ros.cli"), "warn", _("doctor.ros.cli_missing"), _("doctor.ros.hint")
+            )
+        )
+
+    rmw = os.environ.get("RMW_IMPLEMENTATION")
+    if rmw:
+        results.append(CheckResult("ros", _("doctor.ros.rmw"), "ok", rmw))
+    else:
+        results.append(
+            CheckResult("ros", _("doctor.ros.rmw"), "skip", _("doctor.ros.rmw_default"))
+        )
+    return results

caasi/checks/simulators.py

@@ -0,0 +1,41 @@
+"""Alternative simulator checks: Gazebo, MuJoCo."""
+
+from __future__ import annotations
+
+from ..i18n import _
+from ..utils import pydist, shell
+from . import CheckResult, register
+
+
+@register("simulators")
+def check_simulators(ctx) -> list[CheckResult]:
+    results: list[CheckResult] = []
+
+    gz = shell.which("gz") or shell.which("gazebo")
+    if gz:
+        results.append(CheckResult("simulators", _("doctor.sims.gazebo"), "ok", gz))
+    else:
+        results.append(
+            CheckResult(
+                "simulators",
+                _("doctor.sims.gazebo"),
+                "skip",
+                _("doctor.sims.not_installed"),
+                _("doctor.sims.gazebo_hint"),
+            )
+        )
+
+    mujoco = pydist.pip_version("mujoco")
+    if mujoco:
+        results.append(CheckResult("simulators", _("doctor.sims.mujoco"), "ok", mujoco))
+    else:
+        results.append(
+            CheckResult(
+                "simulators",
+                _("doctor.sims.mujoco"),
+                "skip",
+                _("doctor.sims.not_installed"),
+                _("doctor.sims.mujoco_hint"),
+            )
+        )
+    return results