acex-cli 4.5.0__tar.gz → 4.5.1__tar.gz

{acex_cli-4.5.0 → acex_cli-4.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: acex-cli
-Version: 4.5.0
+Version: 4.5.1
 Summary: ACE-X CLI - Command-line interface for ACE-X
 License: AGPL-3.0
 Keywords: automation,cli,control
@@ -11,9 +11,9 @@ Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: acex-client (>=4.3.0,<5.0.0)
-Requires-Dist: acex-devkit (>=1.6.2,<2.0.0)
-Requires-Dist: acex-driver-cisco-ioscli (>=0.5.1,<0.6.0)
+Requires-Dist: acex-client (>=4.8.1,<5.0.0)
+Requires-Dist: acex-devkit (>=2.4.0,<3.0.0)
+Requires-Dist: acex-driver-cisco-ioscli (>=2.7.0,<3.0.0)
 Requires-Dist: click (==8.1.7)
 Requires-Dist: ntc-templates (>=8.1.0,<9.0.0)
 Requires-Dist: rich (>=13.0.0,<14.0.0)

{acex_cli-4.5.0 → acex_cli-4.5.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "acex-cli"
-version = "4.5.0"
+version = "4.5.1"
 description = "ACE-X CLI - Command-line interface for ACE-X"
 authors = ["Johan Lahti <johan.lahti@acebit.se>"]
 readme = "README.md"
@@ -17,14 +17,18 @@ python = "^3.13"
 typer = "^0.12.0"
 rich = "^13.0.0"
 click = "8.1.7"
-acex-client = "^4.3.0" # Changes to real dep. by switch_acex_client_dep for publishing
-acex-devkit = "^1.6.2"
-acex-driver-cisco-ioscli = "^0.5.1"
+acex-client = "^4.8.1" # Changes to real dep. by switch_acex_client_dep for publishing
+acex-devkit = "^2.4.0"
+acex-driver-cisco-ioscli = "^2.7.0"
 ntc-templates = "^8.1.0"
 
 [tool.poetry.scripts]
 acex = "acex_cli.main:app"
 
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-asyncio = "^0.23.0"
+
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/commands/asset.py

@@ -1,10 +1,8 @@
-from typing import Optional
-
 import typer
+from acex_client.models.generated_models import AssetResponse
 
-from acex_cli.sdk import get_sdk
 from acex_cli.output import display_list, display_object
-from acex_client.models.generated_models import AssetResponse
+from acex_cli.sdk import get_sdk
 
 app = typer.Typer(help="Asset resource commands")
 
@@ -13,25 +11,29 @@ app = typer.Typer(help="Asset resource commands")
 def list_cmd(
     ctx: typer.Context,
     # Filters (match backend query params)
-    vendor: Optional[str] = typer.Option(None, help="Filter by vendor (prefix match)"),
-    os: Optional[str] = typer.Option(None, "--os", help="Filter by OS"),
-    hardware_model: Optional[str] = typer.Option(None, help="Filter by hardware model"),
-    ned_id: Optional[str] = typer.Option(None, help="Filter by NED ID"),
-    serial_number: Optional[str] = typer.Option(None, help="Filter by serial number"),
-    assigned: Optional[bool] = typer.Option(None, help="Filter assigned/unassigned"),
+    vendor: str | None = typer.Option(None, help="Filter by vendor (prefix match)"),
+    os: str | None = typer.Option(None, "--os", help="Filter by OS"),
+    hardware_model: str | None = typer.Option(None, help="Filter by hardware model"),
+    ned_id: str | None = typer.Option(None, help="Filter by NED ID"),
+    serial_number: str | None = typer.Option(None, help="Filter by serial number"),
+    assigned: bool | None = typer.Option(None, help="Filter assigned/unassigned"),
     # Pagination
     limit: int = typer.Option(100, "--limit", "-l", help="Max items to return"),
     offset: int = typer.Option(0, "--offset", help="Items to skip"),
     # Output
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
     no_header: bool = typer.Option(False, "--no-header", help="Hide table header"),
 ):
     """List assets with optional filters."""
     sdk = get_sdk(ctx.obj.get_active_context())
     filters = _compact(
-        vendor=vendor, os=os, hardware_model=hardware_model,
-        ned_id=ned_id, serial_number=serial_number, assigned=assigned,
+        vendor=vendor,
+        os=os,
+        hardware_model=hardware_model,
+        ned_id=ned_id,
+        serial_number=serial_number,
+        assigned=assigned,
     )
     result = sdk.assets.query(limit=limit, offset=offset, **filters)
     display_list(
@@ -49,7 +51,7 @@ def show_cmd(
     ctx: typer.Context,
     asset_id: str,
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
 ):
     """Show details for an asset."""
     sdk = get_sdk(ctx.obj.get_active_context())

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/commands/context.py

@@ -1,12 +1,12 @@
 import typer
-from acex_cli.context import CLIContext
 
 app = typer.Typer(help="Context management. Configure API url etc.")
 
+
 @app.command("verify-ssl")
 def verify_ssl(
     value: str = typer.Argument(..., help="Set verify_ssl to true or false", show_default=False, case_sensitive=False),
-    ctx: typer.Context = typer.Context
+    ctx: typer.Context = typer.Context,
 ):
     """Update verify_ssl for the active context. Usage: acex context verify-ssl true|false"""
     value = value.lower()
@@ -23,17 +23,19 @@ def verify_ssl(
     ctx.obj.save()
     typer.echo(f"verify_ssl for active context '{active}' set to {bool_value}.")
 
+
 @app.command()
 def add(
     name: str = typer.Option(..., "--name", help="Context name"),
     url: str = typer.Option(..., "--url", help="API URL"),
     verify_ssl: bool = typer.Option(True, "--verify-ssl/--no-verify-ssl", help="Verify SSL certificates"),
-    ctx: typer.Context = typer.Context
+    ctx: typer.Context = typer.Context,
 ):
     """Set or update a context."""
     ctx.obj.set_context(name, url, verify_ssl=verify_ssl)
     typer.echo(f"Context '{name}' set to {url} (verify_ssl={verify_ssl}) and activated.")
 
+
 @app.command()
 def list(ctx: typer.Context):
     """List all saved contexts."""
@@ -47,12 +49,14 @@ def list(ctx: typer.Context):
         url = data.get("url", "")
         typer.echo(f"{marker} {name}: {url}")
 
+
 @app.command()
 def use(name: str, ctx: typer.Context):
     """Set active context by name."""
     ctx.obj.set_active(name)
     typer.echo(f"Active context set to '{name}'")
 
+
 @app.command()
 def show(ctx: typer.Context):
     """Show active context details."""
@@ -61,4 +65,3 @@ def show(ctx: typer.Context):
         typer.echo(f"Active context: {context}")
     else:
         typer.echo("No active context set.")
-

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/commands/logical_node.py

@@ -1,10 +1,8 @@
-from typing import Optional
-
 import typer
+from acex_client.models.generated_models import LogicalNode
 
-from acex_cli.sdk import get_sdk
 from acex_cli.output import display_list, display_object
-from acex_client.models.generated_models import LogicalNode
+from acex_cli.sdk import get_sdk
 
 app = typer.Typer(help="Logical node resource commands")
 
@@ -13,24 +11,27 @@ app = typer.Typer(help="Logical node resource commands")
 def list_cmd(
     ctx: typer.Context,
     # Filters (match backend query params)
-    role: Optional[str] = typer.Option(None, help="Filter by role (prefix match)"),
-    site: Optional[str] = typer.Option(None, help="Filter by site (prefix match)"),
-    hostname: Optional[str] = typer.Option(None, help="Filter by hostname (prefix match)"),
-    sequence: Optional[int] = typer.Option(None, help="Filter by sequence number"),
-    assigned: Optional[bool] = typer.Option(None, help="Filter assigned/unassigned"),
+    role: str | None = typer.Option(None, help="Filter by role (prefix match)"),
+    site: str | None = typer.Option(None, help="Filter by site (prefix match)"),
+    hostname: str | None = typer.Option(None, help="Filter by hostname (prefix match)"),
+    sequence: int | None = typer.Option(None, help="Filter by sequence number"),
+    assigned: bool | None = typer.Option(None, help="Filter assigned/unassigned"),
     # Pagination
     limit: int = typer.Option(100, "--limit", "-l", help="Max items to return"),
     offset: int = typer.Option(0, "--offset", help="Items to skip"),
     # Output
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
     no_header: bool = typer.Option(False, "--no-header", help="Hide table header"),
 ):
     """List logical nodes with optional filters."""
     sdk = get_sdk(ctx.obj.get_active_context())
     filters = _compact(
-        role=role, site=site, hostname=hostname,
-        sequence=sequence, assigned=assigned,
+        role=role,
+        site=site,
+        hostname=hostname,
+        sequence=sequence,
+        assigned=assigned,
     )
     result = sdk.logical_nodes.query(limit=limit, offset=offset, **filters)
     display_list(
@@ -48,7 +49,7 @@ def show_cmd(
     ctx: typer.Context,
     logical_node_id: str,
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
 ):
     """Show details for a logical node."""
     sdk = get_sdk(ctx.obj.get_active_context())

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/commands/ned.py

@@ -1,10 +1,8 @@
-from typing import Optional
-
 import typer
+from acex_client.models.generated_models import Ned
 
-from acex_cli.sdk import get_sdk
 from acex_cli.output import display_list, display_object
-from acex_client.models.generated_models import Ned
+from acex_cli.sdk import get_sdk
 
 app = typer.Typer(help="NED (Network Element Driver) commands")
 
@@ -14,7 +12,7 @@ def list_cmd(
     ctx: typer.Context,
     # Output (NEDs endpoint has no server-side filters or pagination)
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
     no_header: bool = typer.Option(False, "--no-header", help="Hide table header"),
 ):
     """List available NEDs."""
@@ -35,7 +33,7 @@ def show_cmd(
     ctx: typer.Context,
     ned_id: str,
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
 ):
     """Show details for a NED."""
     sdk = get_sdk(ctx.obj.get_active_context())

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/commands/node.py

@@ -1,27 +1,26 @@
 import base64
 import json
 import os
-from typing import Optional
 
 import requests
 import typer
-
-from acex_cli.sdk import get_sdk
-from acex_cli.output import display_list, display_object
-from acex_cli.print_utils import print_commands_box
 from acex_devkit.models import NodeListItem
 from acex_devkit.models.composed_configuration import ComposedConfiguration
+
 from acex_cli.diff_formatters import (
-    print_diff_summary,
-    print_diff_tree,
     print_diff_compact,
     print_diff_flat,
+    print_diff_summary,
+    print_diff_tree,
 )
-
+from acex_cli.output import display_list, display_object
+from acex_cli.print_utils import print_commands_box
+from acex_cli.sdk import get_sdk
 
 # ── Temporary REST helpers (replace with SDK methods) ───────────
 
-def _request_get(sdk, path: str, params: Optional[dict] = None) -> requests.Response:
+
+def _request_get(sdk, path: str, params: dict | None = None) -> requests.Response:
     verify = getattr(getattr(sdk, "rest", None), "verify", True)
     url = f"{sdk.api_url}{path}"
     response = requests.get(url, params=params, verify=verify)
@@ -30,7 +29,7 @@ def _request_get(sdk, path: str, params: Optional[dict] = None) -> requests.Resp
 
 
 def _get_connection(sdk, node_id):
-    return _request_get(sdk, f"/inventory/management_connections/?node_id={node_id}").json()
+    return _request_get(sdk, f"/inventory/management_connections?node_id={node_id}").json()
 
 
 def _get_rendered_config(sdk, node_id: str) -> str:
@@ -57,6 +56,7 @@ def _fetch_node_instance(sdk, identifier: str):
         if len(result) > 1:
             typer.echo(f"Multiple nodes match '{identifier}':")
             from acex_cli.output import display_list
+
             display_list(result, columns=["id", "hostname", "site", "status"], title="")
             raise typer.Exit(1)
         node = sdk.node_instances.get(result.items[0].id)
@@ -83,6 +83,7 @@ def _resolve_node_quick(sdk, identifier: str):
     if len(result) > 1:
         typer.echo(f"Multiple nodes match '{identifier}':")
         from acex_cli.output import display_list
+
         display_list(result, columns=["id", "hostname", "site", "status"], title="")
         raise typer.Exit(1)
     return result.items[0]
@@ -90,17 +91,17 @@ def _resolve_node_quick(sdk, identifier: str):
 
 def _compile_local(sdk, identifier: str, config_maps_dir: str):
     """Compile config locally from config maps on disk. Returns ComposedConfiguration."""
-    import os
     import importlib.util
+    import os
     import sys
 
     try:
         from acex.config_map import ConfigMap
-        from acex.configuration import Configuration
         from acex.config_map.context import ConfigMapContext
-    except ImportError:
+        from acex.configuration import Configuration
+    except ImportError as exc:
         typer.echo("Backend package 'acex' not installed. Run: pip install -e ../backend")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from exc
 
     if not os.path.isdir(config_maps_dir):
         typer.echo(f"Directory not found: {config_maps_dir}")
@@ -195,28 +196,32 @@ config_app.add_typer(config_diff_app, name="diff")
 
 # ── Node list / show ────────────────────────────────────────────
 
+
 @app.command("list")
 def list_cmd(
     ctx: typer.Context,
     # Filters (match backend query params)
-    site: Optional[str] = typer.Option(None, help="Filter by site (prefix match)"),
-    hostname: Optional[str] = typer.Option(None, help="Filter by hostname (prefix match)"),
-    logical_node_id: Optional[int] = typer.Option(None, help="Filter by logical node ID"),
-    asset_ref_id: Optional[int] = typer.Option(None, help="Filter by asset ref ID"),
-    status: Optional[str] = typer.Option(None, help="Filter by status (planned, init, active, decommissioned)"),
+    site: str | None = typer.Option(None, help="Filter by site (prefix match)"),
+    hostname: str | None = typer.Option(None, help="Filter by hostname (prefix match)"),
+    logical_node_id: int | None = typer.Option(None, help="Filter by logical node ID"),
+    asset_ref_id: int | None = typer.Option(None, help="Filter by asset ref ID"),
+    status: str | None = typer.Option(None, help="Filter by status (planned, init, active, decommissioned)"),
     # Pagination
     limit: int = typer.Option(100, "--limit", "-l", help="Max items to return"),
     offset: int = typer.Option(0, "--offset", help="Items to skip"),
     # Output
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated columns"),
     no_header: bool = typer.Option(False, "--no-header", help="Hide table header"),
 ):
     """List node instances with optional filters."""
     sdk = get_sdk(ctx.obj.get_active_context())
     filters = _compact(
-        site=site, hostname=hostname, logical_node_id=logical_node_id,
-        asset_ref_id=asset_ref_id, status=status,
+        site=site,
+        hostname=hostname,
+        logical_node_id=logical_node_id,
+        asset_ref_id=asset_ref_id,
+        status=status,
     )
     result = sdk.node_instances.query(limit=limit, offset=offset, **filters)
     display_list(
@@ -234,7 +239,7 @@ def show_cmd(
     ctx: typer.Context,
     node: str = typer.Argument(help="Node ID or hostname"),
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json, csv"),
-    columns: Optional[str] = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
+    columns: str | None = typer.Option(None, "--columns", "-c", help="Comma-separated fields"),
 ):
     """Show details for a node instance (by ID or hostname)."""
     sdk = get_sdk(ctx.obj.get_active_context())
@@ -277,7 +282,7 @@ def connect_cmd(
         connections = _get_connection(sdk, node_id)
     except Exception as e:
         typer.echo(f"Failed to fetch management connection: {e}")
-        raise typer.Exit(1)
+        raise typer.Exit(1) from e
 
     if not connections:
         typer.echo(f"No management connection found for node '{node}'.")
@@ -304,13 +309,14 @@ def connect_cmd(
 
 # ── Config show commands ────────────────────────────────────────
 
+
 @config_show_app.command("local")
 def config_show_local(
     ctx: typer.Context,
     node: str = typer.Argument(help="Node ID or hostname"),
     dir: str = typer.Option(..., "--dir", "-d", help="Path to local config_maps directory"),
     render: bool = typer.Option(False, "--render", help="Show rendered device config"),
-    path: Optional[str] = typer.Option(None, "--path", "-p", help="Drill into section"),
+    path: str | None = typer.Option(None, "--path", "-p", help="Drill into section"),
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json"),
 ):
     """Compile config locally from config maps on disk."""
@@ -330,7 +336,7 @@ def config_show_desired(
     ctx: typer.Context,
     node: str = typer.Argument(help="Node ID or hostname"),
     render: bool = typer.Option(False, "--render", help="Show rendered device config"),
-    path: Optional[str] = typer.Option(None, "--path", "-p", help="Drill into section, e.g. system.ntp, interfaces"),
+    path: str | None = typer.Option(None, "--path", "-p", help="Drill into section, e.g. system.ntp, interfaces"),
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json"),
 ):
     """Show desired config."""
@@ -352,7 +358,7 @@ def config_show_observed(
     ctx: typer.Context,
     node: str = typer.Argument(help="Node ID or hostname"),
     render: bool = typer.Option(False, "--render", help="Show rendered device config"),
-    path: Optional[str] = typer.Option(None, "--path", "-p", help="Drill into section, e.g. system.ntp, interfaces"),
+    path: str | None = typer.Option(None, "--path", "-p", help="Drill into section, e.g. system.ntp, interfaces"),
     format: str = typer.Option("table", "--format", "-f", help="Output format: table, json"),
 ):
     """Show observed (backup) config."""
@@ -378,21 +384,24 @@ def config_show_observed(
 
 # ── Config diff commands ────────────────────────────────────────
 
+
 @config_diff_app.command("plan")
 def config_diff_plan(
     ctx: typer.Context,
     node: str = typer.Argument(help="Node ID or hostname"),
     format: str = typer.Option(
-        "tree", "--format", "-f",
+        "tree",
+        "--format",
+        "-f",
         help="Output format: tree, compact, flat, summary, json, commands",
     ),
-    max_depth: Optional[int] = typer.Option(None, "--max-depth", "-d", help="Max depth for tree view"),
+    max_depth: int | None = typer.Option(None, "--max-depth", "-d", help="Max depth for tree view"),
     no_values: bool = typer.Option(False, "--no-values", help="Hide values in tree view"),
 ):
     """Show planned diff between observed and desired config."""
     sdk = get_sdk(ctx.obj.get_active_context())
     node_instance, desired_config = _fetch_desired_config(sdk, node)
-    node_id = str(node_instance.id) if hasattr(node_instance, 'id') and node_instance.id else node
+    node_id = str(node_instance.id) if hasattr(node_instance, "id") and node_instance.id else node
 
     observed_raw = _get_latest_observed_config(sdk, node_id, "parsed").get("content")
     observed_config = ComposedConfiguration(**observed_raw)
@@ -425,7 +434,7 @@ def config_diff_apply(
     """Compute diff and apply config patch to device."""
     sdk = get_sdk(ctx.obj.get_active_context())
     node_instance, desired_config = _fetch_desired_config(sdk, node)
-    node_id = str(node_instance.id) if hasattr(node_instance, 'id') and node_instance.id else node
+    node_id = str(node_instance.id) if hasattr(node_instance, "id") and node_instance.id else node
 
     observed_raw = _get_latest_observed_config(sdk, node_id, "parsed").get("content")
     observed_config = ComposedConfiguration(**observed_raw)
@@ -445,11 +454,13 @@ def config_diff_apply(
 
 # ── Config display helpers ──────────────────────────────────────
 
+
 def _print_rendered(text: str):
     """Print rendered device config with syntax highlighting."""
     from rich.console import Console
-    from rich.syntax import Syntax
     from rich.panel import Panel
+    from rich.syntax import Syntax
+
     console = Console()
     syntax = Syntax(text, "cisco", theme="monokai", line_numbers=True, word_wrap=True)
     console.print(Panel(syntax, border_style="dim"))
@@ -506,10 +517,11 @@ def _count_components(data) -> int:
     return count
 
 
-def _print_parsed_config(data: dict, path: Optional[str], format: str, title: str):
+def _print_parsed_config(data: dict, path: str | None, format: str, title: str):
     """Display parsed config with AttributeValue awareness."""
     from rich.console import Console
     from rich.table import Table
+
     console = Console()
 
     if format == "json":
@@ -527,7 +539,11 @@ def _print_parsed_config(data: dict, path: Optional[str], format: str, title: st
                 console.print(f"  [dim]source: {source}[/dim]")
             return
         # Dict of AttributeValues (e.g. system.config)
-        if isinstance(section, dict) and section and all(_is_attribute_value(v) for v in section.values() if isinstance(v, dict) and v):
+        if (
+            isinstance(section, dict)
+            and section
+            and all(_is_attribute_value(v) for v in section.values() if isinstance(v, dict) and v)
+        ):
             _print_attributes_table(console, section, title=path)
             return
         # Container with named entries (e.g. interfaces, ntp.servers)
@@ -553,12 +569,15 @@ def _print_parsed_config(data: dict, path: Optional[str], format: str, title: st
         )
 
     console.print(table)
-    console.print("[dim]Use --path <section> to drill in, --format json for full dump, --render for device config[/dim]")
+    console.print(
+        "[dim]Use --path <section> to drill in, --format json for full dump, --render for device config[/dim]"
+    )
 
 
 def _print_attributes_table(console, data: dict, title: str = ""):
     """Print a dict where values are AttributeValues as a clean table."""
     from rich.table import Table
+
     table = Table(title=title, show_header=True, title_style="bold", title_justify="left")
     table.add_column("Attribute", style="cyan")
     table.add_column("Value", style="white")
@@ -578,7 +597,6 @@ def _print_attributes_table(console, data: dict, title: str = ""):
 
 def _print_config_section(console, data: dict, path: str):
     """Print a config section, handling containers and nested AttributeValues."""
-    from rich.table import Table
 
     # Check if entries are named components (e.g. interfaces, ntp.servers)
     for entry_name, entry_data in data.items():
@@ -611,6 +629,7 @@ def _print_config_section(console, data: dict, path: str):
 
 # ── Util ────────────────────────────────────────────────────────
 
+
 def _flatten_node(node, node_id: str = None) -> dict:
     """Flatten NodeResponse into a single-level dict for display."""
     data = node.model_dump() if hasattr(node, "model_dump") else dict(node)
@@ -653,6 +672,7 @@ def _resolve_node(sdk, identifier: str):
     elif len(result) > 1:
         typer.echo(f"Multiple nodes match hostname '{identifier}':")
         from acex_cli.output import display_list
+
         display_list(result, columns=["id", "hostname", "site", "status"], title="")
         typer.echo("Use the ID to specify which node.")
         raise typer.Exit(1)
@@ -672,6 +692,7 @@ def _resolve_node_id(sdk, identifier: str) -> str:
     elif len(result) > 1:
         typer.echo(f"Multiple nodes match hostname '{identifier}':")
         from acex_cli.output import display_list
+
         display_list(result, columns=["id", "hostname", "site", "status"], title="")
         typer.echo("Use the ID to specify which node.")
         raise typer.Exit(1)

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/context.py

@@ -3,6 +3,7 @@ from pathlib import Path
 
 CONTEXT_FILE = Path.home() / ".acex/.acex_cli_context.json"
 
+
 class CLIContext:
     def __init__(self):
         self.data = self._load()

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/diff_formatters.py

@@ -1,15 +1,16 @@
 """Formatters for displaying configuration diffs in CLI."""
+
 import json
-from rich.tree import Tree
-from rich.text import Text
-from rich.table import Table
+
+from acex_devkit.configdiffer import ComponentDiffOp, Diff
+from pydantic import BaseModel
 from rich.console import Console
+from rich.table import Table
+from rich.text import Text
+from rich.tree import Tree
 
 console = Console()
 
-from pydantic import BaseModel
-from acex_devkit.configdiffer import Diff, ComponentDiffOp
-
 
 def _as_dict(obj) -> dict:
     """Convert a Pydantic model or dict to a plain dict for iteration."""
@@ -22,54 +23,54 @@ def _as_dict(obj) -> dict:
 
 def print_diff_summary(diff):
     """Print a summary of the diff statistics."""
-    
+
     if not isinstance(diff, Diff):
         console.print("[red]Invalid diff object[/red]")
         return
-    
+
     if diff.is_empty():
         console.print("[green]✓ No changes detected[/green]")
         return
-    
+
     summary = diff.summary()
-    
+
     table = Table(title="Configuration Diff Summary")
     table.add_column("Operation", style="bold")
     table.add_column("Count", style="cyan", justify="right")
-    
+
     if summary.get("added", 0) > 0:
         table.add_row("Added", f"[green]{summary['added']}[/green]")
     if summary.get("removed", 0) > 0:
         table.add_row("Removed", f"[red]{summary['removed']}[/red]")
     if summary.get("changed", 0) > 0:
         table.add_row("Changed", f"[yellow]{summary['changed']}[/yellow]")
-    
+
     console.print(table)
 
 
 def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
     """
     Print diff as a hierarchical tree view.
-    
+
     Args:
         diff: Diff object from configdiffer
         max_depth: Maximum depth to show (None for unlimited)
         show_values: Whether to show before/after values
     """
-    
+
     if not isinstance(diff, Diff):
         console.print("[red]Invalid diff object[/red]")
         return
-    
+
     if diff.is_empty():
         console.print("[green]✓ No changes detected[/green]")
         return
-    
+
     # Create colored title with summary
     summary = diff.summary()
     title = Text("🔀 Configuration Changes ", style="bold")
     title.append("(", style="dim")
-    
+
     parts = []
     if summary.get("added", 0) > 0:
         parts.append((f"+{summary['added']}", "green"))
@@ -77,20 +78,20 @@ def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
         parts.append((f"-{summary['removed']}", "red"))
     if summary.get("changed", 0) > 0:
         parts.append((f"~{summary['changed']}", "yellow"))
-    
+
     for i, (text, color) in enumerate(parts):
         if i > 0:
             title.append(" ", style="dim")
         title.append(text, style=f"bold {color}")
-    
+
     title.append(")", style="dim")
-    
+
     tree = Tree(title)
-    
+
     # Build a hierarchical tree structure based on component paths
     # We'll use a dict to track nodes: path_tuple -> tree_node
     path_nodes = {}
-    
+
     # Group changes by top-level section first to get counts
     sections = {}
     for change in diff.get_all_changes():
@@ -98,28 +99,28 @@ def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
         if section not in sections:
             sections[section] = []
         sections[section].append(change)
-    
+
     # Process each change and build nested structure
     for section_name in sorted(sections.keys()):
         section_changes = sections[section_name]
-        
+
         # Create section node
         section_label = Text()
         section_label.append(section_name, style="bold cyan")
         section_label.append(f" ({len(section_changes)} changes)", style="dim")
         section_node = tree.add(section_label)
         path_nodes[(section_name,)] = section_node
-        
+
         # Add each change, building nested path structure
         for change in section_changes:
             # Build path incrementally
             path = tuple(change.path)
-            
+
             # Find or create parent nodes for nested path
             parent_node = section_node
             for i in range(1, len(path)):
-                partial_path = path[:i+1]
-                
+                partial_path = path[: i + 1]
+
                 # Check if this is the final component or an intermediate path
                 if i == len(path) - 1:
                     # This is the actual component with the change
@@ -132,35 +133,37 @@ def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
                     else:  # CHANGE
                         style = "yellow"
                         prefix = "~ "
-                    
+
                     # Component label
                     comp_label = Text()
                     comp_label.append(prefix, style=f"bold {style}")
                     comp_label.append(f"{change.component_type}: ", style=f"dim {style}")
                     comp_label.append(change.component_name, style=style)
-                    
+
                     comp_node = parent_node.add(comp_label)
-                    
+
                     if show_values:
                         # Show attributes for ADD operations
                         if change.op == ComponentDiffOp.ADD and change.after_dict:
                             for attr_name, attr_value in change.after_dict.items():
                                 # Skip metadata and type fields
-                                if attr_name in ['metadata', 'type']:
+                                if attr_name in ["metadata", "type"]:
                                     continue
                                 attr_label = Text()
                                 attr_label.append("  ", style="dim")
                                 attr_label.append(attr_name, style="cyan")
                                 attr_label.append(": ", style="dim")
                                 formatted_val = _format_value(attr_value)
-                                attr_label.append(formatted_val, style="dim green" if formatted_val == "null" else "green")
+                                attr_label.append(
+                                    formatted_val, style="dim green" if formatted_val == "null" else "green"
+                                )
                                 comp_node.add(attr_label)
-                        
+
                         # Show attributes for REMOVE operations
                         elif change.op == ComponentDiffOp.REMOVE and change.before_dict:
                             for attr_name, attr_value in change.before_dict.items():
                                 # Skip metadata and type fields
-                                if attr_name in ['metadata', 'type']:
+                                if attr_name in ["metadata", "type"]:
                                     continue
                                 attr_label = Text()
                                 attr_label.append("  ", style="dim")
@@ -169,7 +172,7 @@ def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
                                 formatted_val = _format_value(attr_value)
                                 attr_label.append(formatted_val, style="dim red" if formatted_val == "null" else "red")
                                 comp_node.add(attr_label)
-                        
+
                         # Show changed attributes for CHANGE operations
                         elif change.op == ComponentDiffOp.CHANGE and change.changed_attributes:
                             for attr in change.changed_attributes:
@@ -191,43 +194,41 @@ def print_diff_tree(diff, max_depth: int = None, show_values: bool = True):
                         path_node = parent_node.add(path_label)
                         path_nodes[partial_path] = path_node
                     parent_node = path_nodes[partial_path]
-    
+
     console.print(tree)
 
 
 def print_diff_compact(diff, show_unchanged: bool = False):
     """
     Print diff in a compact, git-like format.
-    
+
     Args:
         diff: Diff object from configdiffer
         show_unchanged: Whether to show unchanged paths
     """
-    
+
     if not isinstance(diff, Diff):
         console.print("[red]Invalid diff object[/red]")
         return
-    
+
     if diff.is_empty():
         console.print("[green]✓ No changes detected[/green]")
         return
-    
+
     if diff.added:
         console.print("\n[bold green]✚ Added:[/bold green]")
         for change in diff.added:
-            path = change.get_path_str()
-            console.print(f"  [green]+ {change.component_type_name_name}:[/green] {change.component_name}")
-    
+            console.print(f"  [green]+ {change.component_type_name}:[/green] {change.component_name}")
+
     if diff.removed:
         console.print("\n[bold red]✖ Removed:[/bold red]")
         for change in diff.removed:
-            path = change.get_path_str()
-            console.print(f"  [red]- {change.component_type_name_name}:[/red] {change.component_name}")
-    
+            console.print(f"  [red]- {change.component_type_name}:[/red] {change.component_name}")
+
     if diff.changed:
         console.print("\n[bold yellow]⚡ Modified:[/bold yellow]")
         for change in diff.changed:
-            console.print(f"  [yellow]~ {change.component_type_name_name}:[/yellow] {change.component_name}")
+            console.print(f"  [yellow]~ {change.component_type_name}:[/yellow] {change.component_name}")
             if change.changed_attributes:
                 for attr in change.changed_attributes:
                     before_str = _format_value(attr.before, max_length=40)
@@ -240,19 +241,19 @@ def print_diff_compact(diff, show_unchanged: bool = False):
 def print_diff_flat(diff):
     """
     Print diff in a flat list format, good for quick scanning.
-    
+
     Args:
         diff: Diff object from configdiffer
     """
-    
+
     if not isinstance(diff, Diff):
         console.print("[red]Invalid diff object[/red]")
         return
-    
+
     if diff.is_empty():
         console.print("[green]✓ No changes detected[/green]")
         return
-    
+
     # Create table
     table = Table(title="Configuration Changes", show_lines=True)
     table.add_column("Op", style="bold", width=3)
@@ -261,69 +262,69 @@ def print_diff_flat(diff):
     table.add_column("Attribute", style="magenta")
     table.add_column("Before", style="red", max_width=30)
     table.add_column("After", style="green", max_width=30)
-    
+
     for change in diff.added:
         table.add_row(
             "[green]+[/green]",
-            change.component_type_name_name,
+            change.component_type_name,
             change.component_name,
             "[dim]--[/dim]",
             "",
-            "[dim]new component[/dim]"
+            "[dim]new component[/dim]",
         )
-    
+
     for change in diff.removed:
         table.add_row(
             "[red]-[/red]",
-            change.component_type_name_name,
+            change.component_type_name,
             change.component_name,
             "[dim]--[/dim]",
             "[dim]component deleted[/dim]",
-            ""
+            "",
         )
-    
+
     for change in diff.changed:
         if change.changed_attributes:
             for i, attr in enumerate(change.changed_attributes):
                 table.add_row(
                     "[yellow]~[/yellow]" if i == 0 else "",
-                    change.component_type_name_name if i == 0 else "",
+                    change.component_type_name if i == 0 else "",
                     change.component_name if i == 0 else "",
                     attr.attribute_name,
                     _format_value(attr.before, max_length=30),
-                    _format_value(attr.after, max_length=30)
+                    _format_value(attr.after, max_length=30),
                 )
         else:
             table.add_row(
                 "[yellow]~[/yellow]",
-                change.component_type_name_name,
+                change.component_type_name,
                 change.component_name,
                 "[dim]--[/dim]",
                 "[dim]changed[/dim]",
-                "[dim]changed[/dim]"
+                "[dim]changed[/dim]",
             )
-    
+
     console.print(table)
 
 
 def _format_value(value, max_length: int = 100) -> str:
     """Format a value for display, truncating if necessary."""
-    
+
     if value is None:
         return "null"
-    
+
     # Check if this is an AttributeValue (Pydantic model or dict with 'value' key)
-    if isinstance(value, BaseModel) and hasattr(value, 'value'):
+    if isinstance(value, BaseModel) and hasattr(value, "value"):
         value = value.value
         if value is None:
             return "null"
-    elif isinstance(value, dict) and 'value' in value:
-        value = value['value']
+    elif isinstance(value, dict) and "value" in value:
+        value = value["value"]
         if value is None:
             return "null"
-    
+
     if isinstance(value, BaseModel):
-        value_str = json.dumps(value.model_dump(), separators=(',', ':'))
+        value_str = json.dumps(value.model_dump(), separators=(",", ":"))
     elif isinstance(value, (dict, list)):
         # Convert any nested BaseModel instances before serializing
         def _to_serializable(obj):
@@ -334,12 +335,13 @@ def _format_value(value, max_length: int = 100) -> str:
             if isinstance(obj, list):
                 return [_to_serializable(i) for i in obj]
             return obj
-        value_str = json.dumps(_to_serializable(value), separators=(',', ':'))
+
+        value_str = json.dumps(_to_serializable(value), separators=(",", ":"))
     else:
         value_str = str(value)
-    
+
     # Truncate if too long
     if len(value_str) > max_length:
-        return value_str[:max_length-3] + "..."
-    
+        return value_str[: max_length - 3] + "..."
+
     return value_str

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/main.py

@@ -1,16 +1,16 @@
 """Main CLI application entry point."""
 
-import typer
 import importlib
-import pkgutil
 import pathlib
+import pkgutil
+
+import typer
+
 from acex_cli.context import CLIContext
+from acex_cli.output import console
 
 app = typer.Typer(
-    name="acex",
-    help="ACE-X - Automation & Control Ecosystem CLI",
-    add_completion=True,
-    pretty_exceptions_enable=False
+    name="acex", help="ACE-X - Automation & Control Ecosystem CLI", add_completion=True, pretty_exceptions_enable=False
 )
 
 
@@ -38,9 +38,9 @@ def main(ctx: typer.Context):
 def version():
     """Show version information."""
     from acex_cli import __version__
+
     console.print(f"ACE-X CLI version: {__version__}")
 
 
 if __name__ == "__main__":
     app()
-

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/output.py

@@ -7,10 +7,9 @@ header control, and pagination display.
 import csv
 import io
 import json
-from typing import Optional
 
-from rich.table import Table
 from rich.console import Console
+from rich.table import Table
 
 console = Console()
 
@@ -19,7 +18,7 @@ def display_list(
     result,
     *,
     format: str = "table",
-    columns: Optional[list[str]] = None,
+    columns: list[str] | None = None,
     no_header: bool = False,
     model=None,
     title: str = "",
@@ -47,7 +46,10 @@ def display_list(
         _print_csv(rows, columns, no_header)
     else:
         _print_table(
-            rows, columns, no_header, title,
+            rows,
+            columns,
+            no_header,
+            title,
             total=total,
             limit=getattr(result, "limit", None),
             offset=getattr(result, "offset", None),
@@ -58,8 +60,8 @@ def display_object(
     obj,
     *,
     format: str = "table",
-    columns: Optional[list[str]] = None,
-    exclude: Optional[list[str]] = None,
+    columns: list[str] | None = None,
+    exclude: list[str] | None = None,
     model=None,
     title: str = "",
 ):
@@ -221,6 +223,7 @@ def _format_cell(value) -> str:
     if value is None:
         return ""
     from enum import Enum
+
     if isinstance(value, Enum):
         return value.value
     if isinstance(value, dict) and not value:

{acex_cli-4.5.0 → acex_cli-4.5.1}/src/acex_cli/sdk.py

@@ -1,6 +1,4 @@
 from acex_client.acex.acex import Acex
-import requests
-from requests.exceptions import ConnectionError, SSLError
 
 
 def _innermost_exception_message(exc: Exception) -> str:
@@ -16,7 +14,6 @@ def get_sdk(context):
     url = context.get("url")
     if not url:
         raise RuntimeError("Active context saknar 'url'.")
-    jwt = context.get("jwt")
 
     verify = context.get("verify_ssl", True)
     client = Acex(baseurl=f"{url}/", verify=verify)