ui-cli 1.2.1__py3-none-any.whl

ui_cli/main.py

@@ -0,0 +1,61 @@
+"""UniFi Site Manager CLI - Main entry point."""
+
+import typer
+
+from ui_cli import __version__
+from ui_cli.commands import devices, groups, hosts, isp, mcp, sdwan, sites, speedtest, status, version
+from ui_cli.commands import local
+
+# Create main app
+app = typer.Typer(
+    name="ui",
+    help="UniFi Site Manager CLI - Manage your UniFi infrastructure from the command line.",
+    no_args_is_help=True,
+    add_completion=True,
+)
+
+# Register command groups
+app.add_typer(status.app, name="status")
+app.add_typer(hosts.app, name="hosts")
+app.add_typer(sites.app, name="sites")
+app.add_typer(devices.app, name="devices")
+app.add_typer(isp.app, name="isp")
+app.add_typer(sdwan.app, name="sdwan")
+app.add_typer(version.app, name="version")
+app.add_typer(speedtest.app, name="speedtest")
+
+# Local controller commands (with alias)
+app.add_typer(local.app, name="local")
+app.add_typer(local.app, name="lo")
+
+# MCP server management
+app.add_typer(mcp.app, name="mcp")
+
+# Client groups (local storage, no controller needed)
+app.add_typer(groups.app, name="groups")
+
+
+def version_callback(value: bool) -> None:
+    """Print version and exit."""
+    if value:
+        typer.echo(f"ui-cli version {__version__}")
+        raise typer.Exit()
+
+
+@app.callback()
+def main(
+    version: bool = typer.Option(
+        None,
+        "--version",
+        "-V",
+        callback=version_callback,
+        is_eager=True,
+        help="Show version and exit",
+    ),
+) -> None:
+    """UniFi Site Manager CLI - Manage your UniFi infrastructure from the command line."""
+    pass
+
+
+if __name__ == "__main__":
+    app()

ui_cli/models.py

@@ -0,0 +1,188 @@
+"""Pydantic models for UniFi API responses."""
+
+from datetime import datetime
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+# ========== Host Models ==========
+
+
+class HostReportedState(BaseModel):
+    """Host reported state information."""
+
+    hostname: str | None = None
+    version: str | None = None
+    hardware_id: str | None = Field(None, alias="hardwareId")
+    firmware_version: str | None = Field(None, alias="firmwareVersion")
+    ip_address: str | None = Field(None, alias="ipAddress")
+    mac_address: str | None = Field(None, alias="macAddress")
+
+    class Config:
+        populate_by_name = True
+
+
+class Host(BaseModel):
+    """UniFi host (console/controller) model."""
+
+    id: str
+    hardware_id: str | None = Field(None, alias="hardwareId")
+    type: str | None = None
+    ip_address: str | None = Field(None, alias="ipAddress")
+    is_blocked: bool | None = Field(None, alias="isBlocked")
+    last_connection_state_change: datetime | None = Field(
+        None, alias="lastConnectionStateChange"
+    )
+    latest_backup_time: datetime | None = Field(None, alias="latestBackupTime")
+    registration_time: datetime | None = Field(None, alias="registrationTime")
+    owner: bool | None = None
+    reported_state: HostReportedState | None = Field(None, alias="reportedState")
+    user_data: dict[str, Any] | None = Field(None, alias="userData")
+
+    class Config:
+        populate_by_name = True
+
+
+# ========== Site Models ==========
+
+
+class SiteMeta(BaseModel):
+    """Site metadata."""
+
+    name: str | None = None
+    desc: str | None = None
+    timezone: str | None = None
+    gateway_mac: str | None = Field(None, alias="gatewayMac")
+
+    class Config:
+        populate_by_name = True
+
+
+class SiteStatistics(BaseModel):
+    """Site statistics."""
+
+    counts: dict[str, int] | None = None
+
+    class Config:
+        populate_by_name = True
+
+
+class Site(BaseModel):
+    """UniFi site model."""
+
+    site_id: str | None = Field(None, alias="siteId")
+    host_id: str | None = Field(None, alias="hostId")
+    is_owner: bool | None = Field(None, alias="isOwner")
+    permission: str | None = None
+    meta: SiteMeta | None = None
+    statistics: SiteStatistics | None = None
+    subscription_end_time: datetime | None = Field(None, alias="subscriptionEndTime")
+
+    class Config:
+        populate_by_name = True
+
+
+# ========== Device Models ==========
+
+
+class DeviceUidb(BaseModel):
+    """Device UIDB (database) information."""
+
+    id: str | None = None
+    guid: str | None = None
+    images: dict[str, Any] | None = None
+
+    class Config:
+        populate_by_name = True
+
+
+class Device(BaseModel):
+    """UniFi device model."""
+
+    id: str
+    mac: str | None = None
+    name: str | None = None
+    model: str | None = None
+    shortname: str | None = None
+    ip: str | None = None
+    product_line: str | None = Field(None, alias="productLine")
+    status: str | None = None
+    version: str | None = None
+    firmware_status: str | None = Field(None, alias="firmwareStatus")
+    is_console: bool | None = Field(None, alias="isConsole")
+    is_managed: bool | None = Field(None, alias="isManaged")
+    startup_time: datetime | None = Field(None, alias="startupTime")
+    adoption_time: datetime | None = Field(None, alias="adoptionTime")
+    host_id: str | None = Field(None, alias="hostId")
+    host_name: str | None = Field(None, alias="hostName")
+    updated_at: datetime | None = Field(None, alias="updatedAt")
+    uidb: DeviceUidb | None = None
+
+    class Config:
+        populate_by_name = True
+
+
+# ========== ISP Metrics Models ==========
+
+
+class ISPMetric(BaseModel):
+    """ISP performance metric model."""
+
+    site_id: str | None = Field(None, alias="siteId")
+    host_id: str | None = Field(None, alias="hostId")
+    timestamp: datetime | None = None
+    avg_latency: float | None = Field(None, alias="avgLatency")
+    max_latency: float | None = Field(None, alias="maxLatency")
+    download_kbps: float | None = Field(None, alias="downloadKbps")
+    upload_kbps: float | None = Field(None, alias="uploadKbps")
+    uptime: float | None = None
+    downtime: float | None = None
+    packet_loss: float | None = Field(None, alias="packetLoss")
+    isp_name: str | None = Field(None, alias="ispName")
+    isp_asn: str | None = Field(None, alias="ispAsn")
+
+    class Config:
+        populate_by_name = True
+
+
+# ========== SD-WAN Models ==========
+
+
+class SDWanSettings(BaseModel):
+    """SD-WAN configuration settings."""
+
+    hubs_interconnect: bool | None = Field(None, alias="hubsInterconnect")
+    spoke_to_hub_tunnels_mode: str | None = Field(None, alias="spokeToHubTunnelsMode")
+    spokes_auto_scale_and_nat_enabled: bool | None = Field(
+        None, alias="spokesAutoScaleAndNatEnabled"
+    )
+
+    class Config:
+        populate_by_name = True
+
+
+class SDWanConfig(BaseModel):
+    """SD-WAN configuration model."""
+
+    id: str
+    name: str | None = None
+    type: str | None = None
+    variant: str | None = None
+    settings: SDWanSettings | None = None
+
+    class Config:
+        populate_by_name = True
+
+
+class SDWanStatus(BaseModel):
+    """SD-WAN deployment status model."""
+
+    fingerprint: str | None = None
+    updated_at: datetime | None = Field(None, alias="updatedAt")
+    status: str | None = None
+    progress: float | None = None
+    errors: list[str] | None = None
+
+    class Config:
+        populate_by_name = True

ui_cli/output.py

@@ -0,0 +1,251 @@
+"""Output formatters for table, JSON, and CSV formats."""
+
+import csv
+import io
+import json
+from enum import Enum
+from typing import Any
+
+from rich.console import Console
+from rich.json import JSON
+from rich.table import Table
+
+console = Console()
+
+
+class OutputFormat(str, Enum):
+    """Available output formats."""
+
+    TABLE = "table"
+    JSON = "json"
+    CSV = "csv"
+    YAML = "yaml"
+
+
+def flatten_dict(data: dict[str, Any], parent_key: str = "", sep: str = ".") -> dict[str, Any]:
+    """Flatten nested dictionary for CSV output."""
+    items: list[tuple[str, Any]] = []
+    for key, value in data.items():
+        new_key = f"{parent_key}{sep}{key}" if parent_key else key
+        if isinstance(value, dict):
+            items.extend(flatten_dict(value, new_key, sep=sep).items())
+        elif isinstance(value, list):
+            items.append((new_key, json.dumps(value)))
+        else:
+            items.append((new_key, value))
+    return dict(items)
+
+
+def output_json(data: Any, verbose: bool = False) -> None:
+    """Output data as formatted JSON."""
+    if verbose:
+        console.print(JSON(json.dumps(data, indent=2, default=str)))
+    else:
+        print(json.dumps(data, indent=2, default=str))
+
+
+def get_nested_value(data: dict[str, Any], key: str) -> Any:
+    """Get value from nested dict using dot notation key."""
+    value = data
+    for part in key.split("."):
+        if isinstance(value, dict):
+            value = value.get(part, "")
+        else:
+            return ""
+    return value
+
+
+def output_csv(
+    data: list[dict[str, Any]],
+    columns: list[tuple[str, str]] | None = None,
+) -> None:
+    """Output data as CSV.
+
+    Args:
+        data: List of dictionaries to output
+        columns: Optional list of (key, header) tuples. If None, flattens all fields.
+    """
+    if not data:
+        return
+
+    output = io.StringIO()
+
+    if columns:
+        # Use specified columns with headers
+        headers = [header for _, header in columns]
+        writer = csv.writer(output)
+        writer.writerow(headers)
+
+        for item in data:
+            row = []
+            for key, _ in columns:
+                value = get_nested_value(item, key)
+                if value is None:
+                    value = ""
+                elif isinstance(value, bool):
+                    value = "Yes" if value else "No"
+                elif isinstance(value, (list, dict)):
+                    value = json.dumps(value)
+                else:
+                    value = str(value)
+                row.append(value)
+            writer.writerow(row)
+    else:
+        # Flatten and output all fields
+        flattened = [flatten_dict(item) for item in data]
+        all_keys: set[str] = set()
+        for item in flattened:
+            all_keys.update(item.keys())
+        fieldnames = sorted(all_keys)
+
+        writer = csv.DictWriter(output, fieldnames=fieldnames, extrasaction="ignore")
+        writer.writeheader()
+        for item in flattened:
+            writer.writerow(item)
+
+    print(output.getvalue(), end="")
+
+
+def output_table(
+    data: list[dict[str, Any]],
+    columns: list[tuple[str, str]],
+    title: str | None = None,
+) -> None:
+    """Output data as a Rich table.
+
+    Args:
+        data: List of dictionaries to display
+        columns: List of (key, header) tuples defining columns
+        title: Optional table title
+    """
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+
+    # Add columns
+    for _, header in columns:
+        table.add_column(header)
+
+    # Add rows
+    for item in data:
+        row = []
+        for key, _ in columns:
+            value = item
+            # Handle nested keys like "meta.name"
+            for part in key.split("."):
+                if isinstance(value, dict):
+                    value = value.get(part, "")
+                else:
+                    value = ""
+                    break
+            # Format value
+            if value is None:
+                value = ""
+            elif isinstance(value, bool):
+                value = "Yes" if value else "No"
+            elif isinstance(value, (list, dict)):
+                value = json.dumps(value)
+            else:
+                value = str(value)
+            row.append(value)
+        table.add_row(*row)
+
+    console.print(table)
+
+
+def output_single_table(
+    data: dict[str, Any],
+    title: str | None = None,
+) -> None:
+    """Output a single item as a key-value table."""
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+    table.add_column("Field", style="cyan")
+    table.add_column("Value")
+
+    flat = flatten_dict(data)
+    for key, value in flat.items():
+        if value is None:
+            value = ""
+        elif isinstance(value, bool):
+            value = "Yes" if value else "No"
+        else:
+            value = str(value)
+        table.add_row(key, value)
+
+    console.print(table)
+
+
+def output_count_table(
+    counts: dict[str, int],
+    group_header: str = "Group",
+    count_header: str = "Count",
+    title: str | None = None,
+) -> None:
+    """Output count data as a table with totals."""
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+    table.add_column(group_header)
+    table.add_column(count_header, justify="right")
+
+    total = 0
+    for group, count in sorted(counts.items()):
+        table.add_row(group, str(count))
+        total += count
+
+    # Add separator and total
+    table.add_row("─" * 20, "─" * 10, style="dim")
+    table.add_row("Total", str(total), style="bold")
+
+    console.print(table)
+
+
+def render_output(
+    data: Any,
+    output_format: OutputFormat,
+    columns: list[tuple[str, str]] | None = None,
+    title: str | None = None,
+    verbose: bool = False,
+    is_single: bool = False,
+) -> None:
+    """Render data in the specified format.
+
+    Args:
+        data: Data to render (list or dict)
+        output_format: Output format (table, json, csv)
+        columns: Column definitions for table format [(key, header), ...]
+        title: Title for table output
+        verbose: Enable verbose output
+        is_single: If True, render as single item detail view
+    """
+    if output_format == OutputFormat.JSON:
+        output_json(data, verbose=verbose)
+    elif output_format == OutputFormat.CSV:
+        if isinstance(data, dict):
+            data = [data]
+        output_csv(data, columns=columns)
+    else:  # TABLE
+        if is_single and isinstance(data, dict):
+            output_single_table(data, title=title)
+        elif isinstance(data, list) and columns:
+            output_table(data, columns=columns, title=title)
+        elif isinstance(data, dict):
+            output_single_table(data, title=title)
+        else:
+            console.print(data)
+
+
+def print_error(message: str) -> None:
+    """Print an error message."""
+    console.print(f"[red]Error:[/red] {message}")
+
+
+def print_warning(message: str) -> None:
+    """Print a warning message."""
+    console.print(f"[yellow]Warning:[/yellow] {message}")
+
+
+def print_success(message: str) -> None:
+    """Print a success message."""
+    console.print(f"[green]{message}[/green]")
+
+
+def print_info(message: str) -> None:
+    """Print an info message."""
+    console.print(f"[cyan]{message}[/cyan]")