aptdata 0.0.2__py3-none-any.whl

aptdata/cli/completions.py

@@ -0,0 +1,56 @@
+"""Dynamic autocompletion functions for aptdata CLI commands."""
+
+from __future__ import annotations
+
+
+def complete_system_names(incomplete: str) -> list[str]:
+    """Return registered system names matching *incomplete*."""
+    try:
+        from aptdata.plugins import registry  # noqa: PLC0415
+
+        return [n for n in registry.list_systems() if n.startswith(incomplete)]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def complete_reader_names(incomplete: str) -> list[str]:
+    """Return registered reader plugin names matching *incomplete*."""
+    try:
+        from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+        return [n for n in plugin_manager.list_readers() if n.startswith(incomplete)]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def complete_writer_names(incomplete: str) -> list[str]:
+    """Return registered writer plugin names matching *incomplete*."""
+    try:
+        from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+        return [n for n in plugin_manager.list_writers() if n.startswith(incomplete)]
+    except Exception:  # noqa: BLE001
+        return []
+
+
+def complete_plugin_names(incomplete: str) -> list[str]:
+    """Return all registered plugin names (readers + writers) matching *incomplete*."""
+    return sorted(
+        set(complete_reader_names(incomplete)) | set(complete_writer_names(incomplete))
+    )
+
+
+def complete_env_names(incomplete: str) -> list[str]:
+    """Return common environment names matching *incomplete*."""
+    envs = ["dev", "staging", "prod", "test", "local"]
+    return [e for e in envs if e.startswith(incomplete)]
+
+
+def complete_template_names(incomplete: str) -> list[str]:
+    """Return scaffold template names matching *incomplete*."""
+    try:
+        from aptdata.cli.scaffold import TEMPLATE_NAMES  # noqa: PLC0415
+
+        return [t for t in TEMPLATE_NAMES if t.startswith(incomplete)]
+    except Exception:  # noqa: BLE001
+        return []

aptdata/cli/interactive.py

@@ -0,0 +1,269 @@
+"""Interactive wizard for aptdata CLI.
+
+Uses *questionary* (if available) for prompt-driven UX; falls back to
+plain ``typer.prompt()`` when questionary is not installed.
+"""
+
+from __future__ import annotations
+
+import typer
+
+from aptdata.cli.rendering.console import SmartConsole
+
+_console = SmartConsole(json_mode=False)
+
+# ---------------------------------------------------------------------------
+# questionary availability
+# ---------------------------------------------------------------------------
+
+try:
+    import questionary  # type: ignore[import]
+
+    _HAS_QUESTIONARY = True
+except ModuleNotFoundError:
+    _HAS_QUESTIONARY = False
+
+
+def _select(message: str, choices: list[str]) -> str:
+    """Prompt user to select from *choices*."""
+    if _HAS_QUESTIONARY:
+        answer = questionary.select(message, choices=choices).ask()
+        return answer or choices[0]
+    _console.print(f"\n{message}")
+    for i, c in enumerate(choices, 1):
+        _console.print(f"  {i}. {c}")
+    idx_str = typer.prompt("Enter number", default="1")
+    try:
+        idx = int(idx_str) - 1
+        return choices[max(0, min(idx, len(choices) - 1))]
+    except ValueError:
+        return choices[0]
+
+
+def _text(message: str, default: str = "") -> str:
+    """Prompt user for free text."""
+    if _HAS_QUESTIONARY:
+        answer = questionary.text(message, default=default).ask()
+        return answer if answer is not None else default
+    return typer.prompt(message, default=default)
+
+
+def _confirm(message: str, default: bool = True) -> bool:
+    """Prompt user for yes/no confirmation."""
+    if _HAS_QUESTIONARY:
+        answer = questionary.confirm(message, default=default).ask()
+        return answer if answer is not None else default
+    return typer.confirm(message, default=default)
+
+
+# ---------------------------------------------------------------------------
+# Wizard flows
+# ---------------------------------------------------------------------------
+
+_MAIN_MENU = [
+    "🚀 Run a registered system",
+    "📋 List systems / plugins",
+    "🔍 Inspect a plugin",
+    "📝 Config (validate / run YAML)",
+    "🏗️  Scaffold a new project",
+    "⚙️  Telemetry status",
+    "❌ Exit",
+]
+
+
+def _wizard_run() -> None:
+    """Guided wizard for running a registered system."""
+    from aptdata.plugins import registry  # noqa: PLC0415
+
+    names = registry.list_systems()
+    if not names:
+        _console.warning("No systems registered.")
+        return
+
+    name = _select("Select a system to run:", names)
+    env = _select("Select environment:", ["dev", "staging", "prod"])
+    dry_run = _confirm("Dry run (no execution)?", default=False)
+
+    _console.rule(f"Running '{name}' [{env}]")
+    system_cls = registry.get(name)
+    if system_cls is None:
+        _console.error(f"System '{name}' not found.")
+        return
+
+    try:
+        with _console.spinner(f"Executing '{name}'..."):
+            instance = system_cls(system_id=name)
+            if not dry_run:
+                instance.run()
+        _console.success(f"System '{name}' completed.")
+    except Exception as exc:  # noqa: BLE001
+        _console.error(f"Execution failed: {exc}")
+
+
+def _wizard_list() -> None:
+    """Guided wizard for listing systems / plugins."""
+    from aptdata.cli.rendering.tables import (  # noqa: PLC0415
+        plugins_table,
+        systems_table,
+    )
+    from aptdata.plugins import plugin_manager, registry  # noqa: PLC0415
+
+    choice = _select(
+        "What to list?",
+        ["Systems", "Readers", "Writers", "All plugins"],
+    )
+
+    if choice == "Systems":
+        names = registry.list_systems()
+        if names:
+            _console.render(systems_table(names))
+        else:
+            _console.warning("No systems registered.")
+    elif choice in ("Readers", "Writers", "All plugins"):
+        plugins = plugin_manager.list_plugins()
+        _console.render(plugins_table(plugins))
+
+
+def _wizard_inspect() -> None:
+    """Guided wizard for plugin inspection."""
+    from aptdata.cli.rendering.tables import plugin_schema_table  # noqa: PLC0415
+    from aptdata.plugins import plugin_manager  # noqa: PLC0415
+
+    all_plugins = sorted(plugin_manager.list_readers() + plugin_manager.list_writers())
+    if not all_plugins:
+        _console.warning("No plugins registered.")
+        return
+
+    name = _select("Select a plugin to inspect:", all_plugins)
+    try:
+        schema = plugin_manager.get_plugin_schema(name)
+        _console.render(plugin_schema_table(schema))
+    except KeyError as exc:
+        _console.error(str(exc))
+
+
+def _wizard_config() -> None:
+    """Guided wizard for YAML config validation / run."""
+    from pathlib import Path  # noqa: PLC0415
+
+    from aptdata.cli.rendering.panels import yaml_preview  # noqa: PLC0415
+    from aptdata.cli.rendering.tables import config_summary_table  # noqa: PLC0415
+    from aptdata.config.parser import YamlConfigParser  # noqa: PLC0415
+
+    action = _select("Config action:", ["Load and validate", "Generate template"])
+
+    if action == "Generate template":
+        from aptdata.cli.commands.config_cmd import _STARTER_YAML  # noqa: PLC0415
+
+        out_path_str = _text("Output path:", default="pipeline.yaml")
+        out_path = Path(out_path_str)
+        if out_path.exists():
+            _console.warning(f"File '{out_path}' already exists.")
+        else:
+            out_path.write_text(_STARTER_YAML, encoding="utf-8")
+            _console.success(f"Template written to '{out_path}'.")
+        return
+
+    path_str = _text("Path to YAML file:")
+    if not path_str:
+        _console.warning("No path provided.")
+        return
+    path = Path(path_str)
+    if not path.exists():
+        _console.error(f"File '{path}' not found.")
+        return
+
+    try:
+        parser = YamlConfigParser()
+        parsed = parser.parse_file(path)
+        _console.success("Config is valid.")
+        _console.render(config_summary_table(parsed))
+
+        content = path.read_text(encoding="utf-8")
+        if _confirm("Preview YAML?"):
+            _console.render(yaml_preview(content))
+
+        if _confirm("Run the system?", default=False):
+            with _console.spinner("Running..."):
+                parsed.system.run()
+            _console.success("Done.")
+    except Exception as exc:  # noqa: BLE001
+        _console.error(f"Config error: {exc}")
+
+
+def _wizard_scaffold() -> None:
+    """Guided wizard for project scaffolding."""
+    from aptdata.cli.scaffold import TEMPLATE_NAMES  # noqa: PLC0415
+
+    name = _text("Project name:")
+    if not name:
+        _console.warning("No name provided.")
+        return
+
+    template = _select("Select template:", TEMPLATE_NAMES)
+    output = _text("Output directory:", default=".")
+
+    _console.rule(f"Scaffolding '{name}' [{template}]")
+    try:
+        from typer.testing import CliRunner  # noqa: PLC0415
+
+        from aptdata.cli.app import app  # noqa: PLC0415
+
+        runner = CliRunner()
+        result = runner.invoke(
+            app,
+            ["scaffold", name, "--template", template, "--output", output],
+        )
+        if result.exit_code == 0:
+            _console.success(f"Project '{name}' created in '{output}/{name}'.")
+        else:
+            _console.error(f"Scaffold failed.\n{result.output}")
+    except Exception as exc:  # noqa: BLE001
+        _console.error(f"Scaffold error: {exc}")
+
+
+def _wizard_telemetry() -> None:
+    """Guided wizard for telemetry inspection."""
+    from aptdata.cli.commands.telemetry_cmd import (
+        _get_telemetry_status,  # noqa: PLC0415
+    )
+    from aptdata.cli.rendering.tables import telemetry_status_table  # noqa: PLC0415
+
+    status = _get_telemetry_status()
+    _console.render(telemetry_status_table(status))
+
+    if _confirm("Export telemetry as JSON?", default=False):
+        import json  # noqa: PLC0415
+
+        _console.print(json.dumps({"telemetry": status}, indent=2))
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+
+def interactive_command() -> None:
+    """Launch the interactive wizard for aptdata."""
+    _console.rule("[bold cyan]aptdata interactive wizard[/bold cyan]")
+
+    while True:
+        choice = _select("What would you like to do?", _MAIN_MENU)
+
+        if choice.startswith("🚀"):
+            _wizard_run()
+        elif choice.startswith("📋"):
+            _wizard_list()
+        elif choice.startswith("🔍"):
+            _wizard_inspect()
+        elif choice.startswith("📝"):
+            _wizard_config()
+        elif choice.startswith("🏗"):
+            _wizard_scaffold()
+        elif choice.startswith("⚙"):
+            _wizard_telemetry()
+        elif choice.startswith("❌"):
+            _console.success("Goodbye!")
+            break
+
+        _console.rule()

aptdata/cli/rendering/__init__.py

@@ -0,0 +1,31 @@
+"""Rich rendering layer for aptdata CLI."""
+
+from aptdata.cli.rendering.console import SmartConsole
+from aptdata.cli.rendering.logger import setup_rich_logging
+from aptdata.cli.rendering.panels import (
+    component_panel,
+    flow_tree,
+    system_detail_panel,
+    yaml_preview,
+)
+from aptdata.cli.rendering.tables import (
+    config_summary_table,
+    plugin_schema_table,
+    plugins_table,
+    systems_table,
+    telemetry_status_table,
+)
+
+__all__ = [
+    "SmartConsole",
+    "systems_table",
+    "plugins_table",
+    "plugin_schema_table",
+    "config_summary_table",
+    "telemetry_status_table",
+    "system_detail_panel",
+    "flow_tree",
+    "yaml_preview",
+    "component_panel",
+    "setup_rich_logging",
+]

aptdata/cli/rendering/console.py

@@ -0,0 +1,119 @@
+"""SmartConsole — dual-mode (Rich / JSON) output for aptdata CLI."""
+
+from __future__ import annotations
+
+import json
+import sys
+from collections.abc import Generator
+from contextlib import contextmanager
+from typing import Any
+
+from rich.console import Console
+from rich.status import Status
+from rich.theme import Theme
+
+_THEME = Theme(
+    {
+        "info": "bold cyan",
+        "success": "bold green",
+        "warning": "bold yellow",
+        "error": "bold red",
+        "event": "dim white",
+    }
+)
+
+
+class SmartConsole:
+    """Dual-mode console: Rich for humans, JSON lines for machines.
+
+    Parameters
+    ----------
+    json_mode:
+        When *True*, all output is emitted as JSON lines (backward-compat).
+        When *False* (default), Rich markup is used for human-friendly output.
+    """
+
+    def __init__(self, json_mode: bool = False) -> None:
+        self.json_mode = json_mode
+        self._console = Console(theme=_THEME, highlight=False)
+        self._err_console = Console(theme=_THEME, stderr=True, highlight=False)
+
+    # ------------------------------------------------------------------
+    # Core output helpers
+    # ------------------------------------------------------------------
+
+    def print(self, *args: Any, **kwargs: Any) -> None:
+        """Print to stdout using Rich (or plain text in json_mode)."""
+        if self.json_mode:
+            print(*args, flush=True)
+        else:
+            self._console.print(*args, **kwargs)
+
+    def emit_event(self, event: str, **data: Any) -> None:
+        """Emit a structured event. In JSON mode: JSON line. In Rich mode: formatted."""
+        payload = {"event": event, **data}
+        if self.json_mode:
+            print(json.dumps(payload, default=str), flush=True)
+        else:
+            self._console.print(
+                f"[event]▶ {event}[/event]", json.dumps(data, default=str)
+            )
+
+    def info(self, msg: str) -> None:
+        """Emit an informational message."""
+        if self.json_mode:
+            print(
+                json.dumps({"level": "info", "message": msg}, default=str), flush=True
+            )
+        else:
+            self._console.print(f"[info]ℹ {msg}[/info]")
+
+    def success(self, msg: str) -> None:
+        """Emit a success message."""
+        if self.json_mode:
+            print(
+                json.dumps({"level": "success", "message": msg}, default=str),
+                flush=True,
+            )
+        else:
+            self._console.print(f"[success]✓ {msg}[/success]")
+
+    def warning(self, msg: str) -> None:
+        """Emit a warning message."""
+        if self.json_mode:
+            print(
+                json.dumps({"level": "warning", "message": msg}, default=str),
+                flush=True,
+            )
+        else:
+            self._console.print(f"[warning]⚠ {msg}[/warning]")
+
+    def error(self, msg: str) -> None:
+        """Emit an error message to stderr."""
+        if self.json_mode:
+            print(
+                json.dumps({"level": "error", "message": msg}, default=str),
+                file=sys.stderr,
+                flush=True,
+            )
+        else:
+            self._err_console.print(f"[error]✗ {msg}[/error]")
+
+    def rule(self, title: str = "") -> None:
+        """Print a horizontal rule (no-op in json_mode)."""
+        if not self.json_mode:
+            self._console.rule(title)
+
+    def render(self, renderable: Any) -> None:
+        """Render a Rich renderable (table, panel, tree, …). No-op in json_mode."""
+        if not self.json_mode:
+            self._console.print(renderable)
+
+    @contextmanager
+    def spinner(self, msg: str) -> Generator[None, None, None]:
+        """Context manager that shows a spinner in Rich mode (no-op in json_mode)."""
+        if self.json_mode:
+            yield
+        else:
+            with Status(msg, console=self._console):
+                yield

aptdata/cli/rendering/logger.py

@@ -0,0 +1,26 @@
+"""Rich logging setup for aptdata CLI."""
+
+from __future__ import annotations
+
+import logging
+
+
+def setup_rich_logging(level: int = logging.INFO) -> None:
+    """Configure the root logger to use RichHandler for human-friendly output.
+
+    Parameters
+    ----------
+    level:
+        Logging level (default: INFO).
+    """
+    try:
+        from rich.logging import RichHandler  # noqa: PLC0415
+
+        logging.basicConfig(
+            level=level,
+            format="%(message)s",
+            datefmt="[%X]",
+            handlers=[RichHandler(rich_tracebacks=True, markup=True)],
+        )
+    except ImportError:
+        logging.basicConfig(level=level)

aptdata/cli/rendering/panels.py

@@ -0,0 +1,87 @@
+"""Rich panel / tree generators for aptdata CLI output."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from rich.panel import Panel
+from rich.syntax import Syntax
+from rich.tree import Tree
+
+
+def system_detail_panel(name: str, system_cls: Any) -> Panel:
+    """Return a Rich Panel with detailed system information."""
+    doc = (system_cls.__doc__ or "No description.").strip()
+    module = getattr(system_cls, "__module__", "unknown")
+    content = (
+        f"[bold]Class:[/bold] {system_cls.__name__}\n"
+        f"[bold]Module:[/bold] {module}\n\n{doc}"
+    )
+    return Panel(content, title=f"[bold cyan]System: {name}[/bold cyan]", expand=False)
+
+
+def flow_tree(flow: Any) -> Tree:
+    """Return a Rich Tree representing the flow's component DAG."""
+    tree = Tree(f"[bold]{getattr(flow, 'flow_id', 'flow')}[/bold]")
+    components = getattr(flow, "components", [])
+    edges = getattr(flow, "edges", [])
+
+    # Build adjacency for display
+    children: dict[str, list[str]] = {}
+    for edge in edges:
+        src = getattr(edge, "source_id", "?")
+        tgt = getattr(edge, "target_id", "?")
+        children.setdefault(src, []).append(tgt)
+
+    added: set[str] = set()
+
+    def _add(node: str, branch: Any) -> None:
+        if node in added:
+            return
+        added.add(node)
+        b = branch.add(f"[green]{node}[/green]")
+        for child in children.get(node, []):
+            _add(child, b)
+
+    component_ids = [
+        getattr(c, "component_id", str(i)) for i, c in enumerate(components)
+    ]
+    all_targets: set[str] = {t for targets in children.values() for t in targets}
+    roots = [cid for cid in component_ids if cid not in all_targets]
+    if not roots:
+        roots = component_ids[:1]
+
+    for root in roots:
+        _add(root, tree)
+
+    # Add any unconnected components
+    for cid in component_ids:
+        if cid not in added:
+            tree.add(f"[dim]{cid}[/dim]")
+
+    return tree
+
+
+def yaml_preview(content: str) -> Syntax:
+    """Return a Rich Syntax object for YAML content."""
+    return Syntax(content, "yaml", theme="monokai", line_numbers=True)
+
+
+def component_panel(component: Any) -> Panel:
+    """Return a Rich Panel with component metadata."""
+    cid = getattr(component, "component_id", "unknown")
+    meta = getattr(component, "metadata", None)
+    lines = [f"[bold]ID:[/bold] {cid}"]
+    if meta is not None:
+        kind = getattr(meta, "kind", None)
+        if kind is not None:
+            lines.append(f"[bold]Kind:[/bold] {kind}")
+        tags = getattr(meta, "tags", [])
+        if tags:
+            lines.append(f"[bold]Tags:[/bold] {', '.join(tags)}")
+        desc = getattr(meta, "description", "")
+        if desc:
+            lines.append(f"[bold]Description:[/bold] {desc}")
+    return Panel(
+        "\n".join(lines), title=f"[bold cyan]Component: {cid}[/bold cyan]", expand=False
+    )

aptdata/cli/rendering/tables.py

@@ -0,0 +1,81 @@
+"""Rich table generators for aptdata CLI output."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from rich.table import Table
+
+if TYPE_CHECKING:
+    from aptdata.config.parser import ParsedConfig
+
+
+def systems_table(names: list[str]) -> Table:
+    """Return a Rich Table of registered system names."""
+    table = Table(
+        title="Registered Systems", show_header=True, header_style="bold cyan"
+    )
+    table.add_column("#", style="dim", width=4)
+    table.add_column("Name", style="bold")
+    for i, name in enumerate(names, 1):
+        table.add_row(str(i), name)
+    return table
+
+
+def plugins_table(plugins: dict[str, list[str]]) -> Table:
+    """Return a Rich Table of readers and writers."""
+    table = Table(
+        title="Registered Plugins", show_header=True, header_style="bold cyan"
+    )
+    table.add_column("Kind", style="bold magenta", width=10)
+    table.add_column("Name", style="bold")
+    for name in plugins.get("readers", []):
+        table.add_row("reader", name)
+    for name in plugins.get("writers", []):
+        table.add_row("writer", name)
+    return table
+
+
+def plugin_schema_table(schema: dict[str, Any]) -> Table:
+    """Return a Rich Table of constructor arguments for a plugin."""
+    table = Table(
+        title=f"Plugin Schema: {schema.get('name', '')} ({schema.get('type', '')})",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("Argument", style="bold")
+    table.add_column("Required", style="bold yellow")
+    table.add_column("Default", style="dim")
+    for arg in schema.get("arguments", []):
+        required = "✓" if arg.get("required") else ""
+        default = str(arg.get("default", "")) if not arg.get("required") else "-"
+        table.add_row(arg["name"], required, default)
+    return table
+
+
+def config_summary_table(parsed: ParsedConfig) -> Table:
+    """Return a Rich Table summarising a parsed YAML config."""
+    table = Table(title="Config Summary", show_header=True, header_style="bold cyan")
+    table.add_column("Field", style="bold")
+    table.add_column("Value")
+
+    meta = parsed.metadata
+    system = parsed.system
+
+    table.add_row("system_id", system.system_id)
+    table.add_row("flows", str(len(getattr(system, "flows", []))))
+
+    for key, value in meta.items():
+        table.add_row(f"metadata.{key}", str(value))
+
+    return table
+
+
+def telemetry_status_table(status: dict[str, Any]) -> Table:
+    """Return a Rich Table of OpenTelemetry status."""
+    table = Table(title="Telemetry Status", show_header=True, header_style="bold cyan")
+    table.add_column("Key", style="bold")
+    table.add_column("Value")
+    for key, value in status.items():
+        table.add_row(str(key), str(value))
+    return table