aptdata 0.0.2__py3-none-any.whl

aptdata/cli/commands/mesh_cmd.py

@@ -0,0 +1,435 @@
+"""CLI sub-commands for mesh component orchestration."""
+
+from __future__ import annotations
+
+import json
+import subprocess
+from pathlib import Path
+
+import typer
+
+from aptdata.cli.rendering.console import SmartConsole
+
+mesh_app = typer.Typer(
+    name="mesh", help="Orchestrate mesh components (job-wheel, docker-compose-app, …)."
+)
+
+_MESH_FILE = "mesh.yaml"
+
+
+def _load_mesh(path: Path) -> dict:
+    """Load and parse a mesh.yaml file."""
+    try:
+        import yaml  # type: ignore[import]
+    except ImportError:
+        # Minimal YAML parser for simple key: value lines (no external dep required)
+        import re
+
+        # Minimal fallback parser: handles only top-level scalar key: value lines.
+        # Does NOT support nested structures, lists, or multi-line values.
+        # Install PyYAML (`pip install pyyaml`) for full YAML support.
+        data: dict = {}
+        for line in path.read_text(encoding="utf-8").splitlines():
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            match = re.match(r'^(\w[\w\-]*):\s*"?([^"]*)"?\s*$', line)
+            if match:
+                data[match.group(1)] = match.group(2).strip()
+        return data
+
+    return yaml.safe_load(path.read_text(encoding="utf-8")) or {}
+
+
+def _find_mesh_yaml(directory: Path) -> Path | None:  # noqa: UP007
+    """Return the path to mesh.yaml in *directory* or None if not found."""
+    candidate = directory / _MESH_FILE
+    return candidate if candidate.exists() else None
+
+
+@mesh_app.command("list")
+def mesh_list(
+    directory: Path = typer.Option(
+        Path("."),
+        "--dir",
+        "-d",
+        help="Directory to scan for mesh.yaml files.",
+        exists=False,
+        file_okay=False,
+        dir_okay=True,
+        resolve_path=True,
+    ),
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """List mesh components found under *directory*.
+
+    Recursively searches for mesh.yaml files and displays component metadata.
+
+    Examples
+    --------
+    aptdata mesh list
+    aptdata mesh list --dir ./projects
+    """
+    console = SmartConsole(json_mode=json_mode)
+    root = directory.resolve()
+    components: list[dict] = []
+
+    for mesh_file in sorted(root.rglob(_MESH_FILE)):
+        try:
+            data = _load_mesh(mesh_file)
+            components.append(
+                {
+                    "component": data.get("component", mesh_file.parent.name),
+                    "type": data.get("type", "unknown"),
+                    "version": data.get("version", ""),
+                    "path": str(mesh_file.parent),
+                }
+            )
+        except Exception as exc:  # noqa: BLE001
+            components.append(
+                {
+                    "component": mesh_file.parent.name,
+                    "type": "unknown",
+                    "version": "",
+                    "path": str(mesh_file.parent),
+                    "error": str(exc),
+                }
+            )
+
+    if json_mode:
+        print(
+            json.dumps({"components": components, "count": len(components)}), flush=True
+        )
+    else:
+        if not components:
+            console.warning(f"No mesh.yaml files found under '{root}'.")
+            return
+
+        from rich.table import Table  # noqa: PLC0415
+
+        table = Table(title="Mesh Components", show_header=True)
+        table.add_column("Component", style="cyan")
+        table.add_column("Type", style="magenta")
+        table.add_column("Version")
+        table.add_column("Path", style="dim")
+        for c in components:
+            table.add_row(c["component"], c["type"], c["version"], c["path"])
+        console.render(table)
+
+
+@mesh_app.command("run")
+def mesh_run(
+    component: str = typer.Argument(
+        ..., help="Component name or path containing mesh.yaml."
+    ),
+    directory: Path = typer.Option(
+        Path("."),
+        "--dir",
+        "-d",
+        help="Base directory to search for the component.",
+        exists=False,
+        resolve_path=True,
+    ),
+    dry_run: bool = typer.Option(
+        False, "--dry-run", help="Show what would run without executing."
+    ),
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """Run a mesh component by name.
+
+    Locates the component's mesh.yaml, detects its type, and executes it.
+
+    Supported types
+    ---------------
+    * ``job-wheel``          — runs the installed wheel entry-point
+    * ``docker-compose-app`` — runs ``docker compose up`` in the component dir
+
+    Examples
+    --------
+    aptdata mesh run my_job
+    aptdata mesh run my_app --dry-run
+    """
+    console = SmartConsole(json_mode=json_mode)
+    root = directory.resolve()
+
+    # Find mesh.yaml for the given component (by name or direct path)
+    mesh_file: Path | None = None  # noqa: UP007
+    component_path = root / component
+    if component_path.is_dir():
+        mesh_file = _find_mesh_yaml(component_path)
+    if mesh_file is None:
+        for candidate in root.rglob(_MESH_FILE):
+            try:
+                data = _load_mesh(candidate)
+                if data.get("component") == component:
+                    mesh_file = candidate
+                    break
+            except Exception:  # noqa: BLE001
+                continue
+
+    if mesh_file is None:
+        msg = f"Component '{component}' not found. No mesh.yaml located under '{root}'."
+        if json_mode:
+            print(
+                json.dumps(
+                    {"event": "mesh.error", "component": component, "error": msg}
+                ),
+                flush=True,
+            )
+        else:
+            console.error(msg)
+        raise typer.Exit(1)
+
+    config = _load_mesh(mesh_file)
+    comp_type = config.get("type", "unknown")
+    comp_dir = mesh_file.parent
+
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "event": "mesh.run.started",
+                    "component": component,
+                    "type": comp_type,
+                    "dry_run": dry_run,
+                }
+            ),
+            flush=True,
+        )
+    else:
+        console.info(f"Running component [bold cyan]{component}[/] (type: {comp_type})")
+
+    if dry_run:
+        _show_dry_run(component, comp_type, comp_dir, config, json_mode, console)
+        return
+
+    try:
+        if comp_type == "job-wheel":
+            _run_job_wheel(component, comp_dir, config)
+        elif comp_type == "docker-compose-app":
+            _run_docker_compose(component, comp_dir, config)
+        else:
+            raise ValueError(f"Unsupported component type '{comp_type}'.")
+    except Exception as exc:  # noqa: BLE001
+        if json_mode:
+            print(
+                json.dumps(
+                    {
+                        "event": "mesh.run.error",
+                        "component": component,
+                        "error": str(exc),
+                    }
+                ),
+                flush=True,
+            )
+        else:
+            console.error(f"Failed to run '{component}': {exc}")
+        raise typer.Exit(1) from exc
+
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "event": "mesh.run.completed",
+                    "component": component,
+                    "type": comp_type,
+                }
+            ),
+            flush=True,
+        )
+    else:
+        console.success(f"Component [bold cyan]{component}[/] finished successfully.")
+
+
+@mesh_app.command("build")
+def mesh_build(
+    component: str = typer.Argument(
+        ..., help="Component name or path containing mesh.yaml."
+    ),
+    directory: Path = typer.Option(
+        Path("."),
+        "--dir",
+        "-d",
+        help="Base directory to search for the component.",
+        exists=False,
+        resolve_path=True,
+    ),
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """Build a mesh component.
+
+    Supported types
+    ---------------
+    * ``job-wheel``          — builds the Python wheel (``pip wheel .``)
+    * ``docker-compose-app`` — builds Docker images (``docker compose build``)
+
+    Examples
+    --------
+    aptdata mesh build my_job
+    aptdata mesh build my_app --json
+    """
+    console = SmartConsole(json_mode=json_mode)
+    root = directory.resolve()
+
+    mesh_file: Path | None = None  # noqa: UP007
+    component_path = root / component
+    if component_path.is_dir():
+        mesh_file = _find_mesh_yaml(component_path)
+    if mesh_file is None:
+        for candidate in root.rglob(_MESH_FILE):
+            try:
+                data = _load_mesh(candidate)
+                if data.get("component") == component:
+                    mesh_file = candidate
+                    break
+            except Exception:  # noqa: BLE001
+                continue
+
+    if mesh_file is None:
+        msg = f"Component '{component}' not found. No mesh.yaml located under '{root}'."
+        if json_mode:
+            print(
+                json.dumps(
+                    {"event": "mesh.error", "component": component, "error": msg}
+                ),
+                flush=True,
+            )
+        else:
+            console.error(msg)
+        raise typer.Exit(1)
+
+    config = _load_mesh(mesh_file)
+    comp_type = config.get("type", "unknown")
+    comp_dir = mesh_file.parent
+
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "event": "mesh.build.started",
+                    "component": component,
+                    "type": comp_type,
+                }
+            ),
+            flush=True,
+        )
+    else:
+        console.info(
+            f"Building component [bold cyan]{component}[/] (type: {comp_type})"
+        )
+
+    try:
+        if comp_type == "job-wheel":
+            _build_job_wheel(component, comp_dir)
+        elif comp_type == "docker-compose-app":
+            _build_docker_compose(component, comp_dir)
+        else:
+            raise ValueError(f"Unsupported component type '{comp_type}'.")
+    except Exception as exc:  # noqa: BLE001
+        if json_mode:
+            print(
+                json.dumps(
+                    {
+                        "event": "mesh.build.error",
+                        "component": component,
+                        "error": str(exc),
+                    }
+                ),
+                flush=True,
+            )
+        else:
+            console.error(f"Failed to build '{component}': {exc}")
+        raise typer.Exit(1) from exc
+
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "event": "mesh.build.completed",
+                    "component": component,
+                    "type": comp_type,
+                }
+            ),
+            flush=True,
+        )
+    else:
+        console.success(f"Component [bold cyan]{component}[/] built successfully.")
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+
+def _show_dry_run(
+    component: str,
+    comp_type: str,
+    comp_dir: Path,
+    config: dict,
+    json_mode: bool,
+    console: SmartConsole,
+) -> None:
+    if comp_type == "job-wheel":
+        entrypoint = config.get("run", {}).get("entrypoint", component)
+        cmd = [entrypoint] + config.get("run", {}).get("args", [])
+    elif comp_type == "docker-compose-app":
+        cmd = ["docker", "compose", "up"]
+    else:
+        cmd = ["<unknown>"]
+
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "event": "mesh.run.dry_run",
+                    "component": component,
+                    "type": comp_type,
+                    "command": cmd,
+                }
+            ),
+            flush=True,
+        )
+    else:
+        console.info(f"[dry-run] Would execute: {' '.join(cmd)} in {comp_dir}")
+
+
+def _run_job_wheel(component: str, comp_dir: Path, config: dict) -> None:
+    run_cfg = config.get("run", {})
+    if isinstance(run_cfg, dict):
+        entrypoint = run_cfg.get("entrypoint", f"{component}-job")
+        args = run_cfg.get("args", [])
+    else:
+        entrypoint = f"{component}-job"
+        args = []
+    cmd = [entrypoint, *args]
+    result = subprocess.run(cmd, cwd=comp_dir, check=False)  # noqa: S603
+    if result.returncode != 0:
+        raise RuntimeError(f"Job '{component}' exited with code {result.returncode}.")
+
+
+def _run_docker_compose(component: str, comp_dir: Path, config: dict) -> None:
+    cmd = ["docker", "compose", "up"]
+    result = subprocess.run(cmd, cwd=comp_dir, check=False)  # noqa: S603
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"Docker Compose app '{component}' exited with code {result.returncode}."
+        )
+
+
+def _build_job_wheel(component: str, comp_dir: Path) -> None:
+    cmd = ["pip", "wheel", ".", "-w", "dist/", "--no-deps"]
+    result = subprocess.run(cmd, cwd=comp_dir, check=False)  # noqa: S603
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"Wheel build for '{component}' failed with code {result.returncode}."
+        )
+
+
+def _build_docker_compose(component: str, comp_dir: Path) -> None:
+    cmd = ["docker", "compose", "build"]
+    result = subprocess.run(cmd, cwd=comp_dir, check=False)  # noqa: S603
+    if result.returncode != 0:
+        raise RuntimeError(
+            f"Docker Compose build for '{component}' failed"
+            f" with code {result.returncode}."
+        )

aptdata/cli/commands/plugin_cmd.py

@@ -0,0 +1,107 @@
+"""CLI sub-commands for plugin management."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from aptdata.cli.rendering.console import SmartConsole
+from aptdata.cli.rendering.tables import plugin_schema_table, plugins_table
+
+plugin_app = typer.Typer(name="plugin", help="Manage and inspect plugins.")
+
+
+@plugin_app.command("list")
+def plugin_list(
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """List all registered reader and writer plugins."""
+    from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=json_mode)
+    plugins = plugin_manager.list_plugins()
+
+    if json_mode:
+        print(json.dumps(plugins), flush=True)
+    else:
+        if not plugins.get("readers") and not plugins.get("writers"):
+            console.warning("No plugins registered.")
+        else:
+            console.render(plugins_table(plugins))
+
+
+@plugin_app.command("inspect")
+def plugin_inspect(
+    name: str = typer.Argument(..., help="Plugin name."),
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """Show constructor schema for a plugin."""
+    from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=json_mode)
+
+    try:
+        schema = plugin_manager.get_plugin_schema(name)
+    except KeyError as exc:
+        console.error(str(exc))
+        raise typer.Exit(1) from exc
+
+    if json_mode:
+        print(json.dumps(schema, default=str), flush=True)
+    else:
+        console.render(plugin_schema_table(schema))
+
+
+@plugin_app.command("preview")
+def plugin_preview(
+    reader: str = typer.Argument(..., help="Reader plugin name."),
+    limit: int = typer.Option(5, "--limit", "-n", help="Number of records to preview."),
+) -> None:
+    """Execute a reader plugin and preview the first N records."""
+    from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=False)
+
+    try:
+        with console.spinner(f"Reading from '{reader}'..."):
+            records = plugin_manager.preview_dataset(reader)
+        records = records[:limit]
+        if not records:
+            console.warning("No records returned.")
+        else:
+            from rich.table import Table  # noqa: PLC0415
+
+            table = Table(title=f"Preview: {reader} (first {len(records)} records)")
+            for col in records[0].keys():
+                table.add_column(str(col))
+            for row in records:
+                table.add_row(*[str(v) for v in row.values()])
+            console.render(table)
+    except KeyError as exc:
+        console.error(str(exc))
+        raise typer.Exit(1) from exc
+    except Exception as exc:  # noqa: BLE001
+        console.error(f"Preview failed: {exc}")
+        raise typer.Exit(1) from exc
+
+
+@plugin_app.command("load")
+def plugin_load(
+    module_path: str = typer.Argument(..., help="Dotted Python module path to load."),
+) -> None:
+    """Dynamically import a plugin module."""
+    from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=False)
+
+    try:
+        with console.spinner(f"Loading '{module_path}'..."):
+            mod = plugin_manager.load_module(module_path)
+        console.success(f"Module '{mod.__name__}' loaded successfully.")
+    except ModuleNotFoundError as exc:
+        console.error(f"Module not found: {exc}")
+        raise typer.Exit(1) from exc
+    except Exception as exc:  # noqa: BLE001
+        console.error(f"Load failed: {exc}")
+        raise typer.Exit(1) from exc

aptdata/cli/commands/system_cmd.py

@@ -0,0 +1,90 @@
+"""CLI sub-commands for system registry management."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from aptdata.cli.rendering.console import SmartConsole
+from aptdata.cli.rendering.panels import system_detail_panel
+from aptdata.cli.rendering.tables import systems_table
+
+system_app = typer.Typer(name="system", help="Inspect and validate registered systems.")
+
+
+@system_app.command("list")
+def system_list(
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """List all registered systems."""
+    from aptdata.plugins import registry  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=json_mode)
+    names = registry.list_systems()
+
+    if json_mode:
+        print(json.dumps({"systems": names, "count": len(names)}), flush=True)
+    else:
+        if not names:
+            console.warning("No systems registered.")
+        else:
+            console.render(systems_table(names))
+
+
+@system_app.command("info")
+def system_info(
+    name: str = typer.Argument(..., help="System name."),
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """Show detailed info about a registered system."""
+    from aptdata.plugins import registry  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=json_mode)
+    system_cls = registry.get(name)
+
+    if system_cls is None:
+        console.error(f"System '{name}' not found in registry.")
+        raise typer.Exit(1)
+
+    if json_mode:
+        print(
+            json.dumps(
+                {
+                    "name": name,
+                    "class": system_cls.__name__,
+                    "module": getattr(system_cls, "__module__", "unknown"),
+                    "doc": (system_cls.__doc__ or "").strip(),
+                }
+            ),
+            flush=True,
+        )
+    else:
+        console.render(system_detail_panel(name, system_cls))
+
+
+@system_app.command("validate")
+def system_validate(
+    name: str = typer.Argument(..., help="System name."),
+) -> None:
+    """Instantiate a system and compile all its flows without executing."""
+    from aptdata.plugins import registry  # noqa: PLC0415
+
+    console = SmartConsole(json_mode=False)
+    system_cls = registry.get(name)
+
+    if system_cls is None:
+        console.error(f"System '{name}' not found in registry.")
+        raise typer.Exit(1)
+
+    try:
+        with console.spinner(f"Validating system '{name}'..."):
+            instance = system_cls(system_id=name)
+            flows = getattr(instance, "_flows", None) or getattr(instance, "flows", [])
+            for flow in flows:
+                if hasattr(flow, "compile"):
+                    flow.compile()
+        console.success(f"System '{name}' validated successfully.")
+    except Exception as exc:  # noqa: BLE001
+        console.error(f"Validation failed: {exc}")
+        raise typer.Exit(1) from exc

aptdata/cli/commands/telemetry_cmd.py

@@ -0,0 +1,57 @@
+"""CLI sub-commands for telemetry management."""
+
+from __future__ import annotations
+
+import json
+
+import typer
+
+from aptdata.cli.rendering.console import SmartConsole
+from aptdata.cli.rendering.tables import telemetry_status_table
+
+telemetry_app = typer.Typer(
+    name="telemetry", help="Inspect OpenTelemetry telemetry status."
+)
+
+
+def _get_telemetry_status() -> dict:
+    """Return a dict describing the current OTel tracer provider."""
+    from opentelemetry import trace  # noqa: PLC0415
+
+    provider = trace.get_tracer_provider()
+    provider_type = type(provider).__name__
+    configured = provider_type != "ProxyTracerProvider"
+    return {
+        "configured": configured,
+        "provider": provider_type,
+        "service": "aptdata",
+    }
+
+
+@telemetry_app.command("status")
+def telemetry_status(
+    json_mode: bool = typer.Option(False, "--json", help="Emit JSON lines."),
+) -> None:
+    """Show OpenTelemetry configuration status."""
+    console = SmartConsole(json_mode=json_mode)
+    status = _get_telemetry_status()
+
+    if json_mode:
+        print(json.dumps(status), flush=True)
+    else:
+        console.render(telemetry_status_table(status))
+
+
+@telemetry_app.command("export")
+def telemetry_export(
+    fmt: str = typer.Option("json", "--format", "-f", help="Export format (json)."),
+) -> None:
+    """Export collected telemetry spans/metrics."""
+    console = SmartConsole(json_mode=False)
+    status = _get_telemetry_status()
+
+    if fmt == "json":
+        console.print(json.dumps({"telemetry": status}, indent=2, default=str))
+    else:
+        console.error(f"Unsupported format: {fmt}")
+        raise typer.Exit(1)