devnomads-cli 0.5.1__tar.gz → 0.5.3__tar.gz

{devnomads_cli-0.5.1 → devnomads_cli-0.5.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devnomads-cli
-Version: 0.5.1
+Version: 0.5.3
 Summary: Manage your DevNomads services from the command line
 Author-email: DevNomads <support@devnomads.nl>
 License: MIT

{devnomads_cli-0.5.1 → devnomads_cli-0.5.3}/devnomads_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devnomads-cli
-Version: 0.5.1
+Version: 0.5.3
 Summary: Manage your DevNomads services from the command line
 Author-email: DevNomads <support@devnomads.nl>
 License: MIT

{devnomads_cli-0.5.1 → devnomads_cli-0.5.3}/dncli.py

@@ -44,6 +44,7 @@ from devnomads.api import Client as ApiClient
 from devnomads.api import DevNomadsError
 from devnomads.api.client import _unwrap as _lib_unwrap
 from devnomads.dns import Dns, challenge_name
+from rich import box
 from rich.console import Console
 from rich.markup import escape
 from rich.table import Table
@@ -211,16 +212,74 @@ def render(
         out_console.print(str(data), soft_wrap=True)
 
 
-def _cell(value: Any) -> str:
+def _summarize_item(item: dict[str, Any]) -> str:
+    """Compact one-line ``key=value`` view of an object's scalar fields for a
+    table cell. Nested lists/objects collapse to a count so the line stays
+    short; None and empty fields are dropped."""
+
+    parts = []
+    for key, val in item.items():
+        if val is None or val == "":
+            continue
+        if isinstance(val, bool):
+            parts.append(f"{key}={'yes' if val else 'no'}")
+        elif isinstance(val, dict):
+            if val:
+                parts.append(f"{key}={{{len(val)}}}")
+        elif isinstance(val, list):
+            if val:
+                parts.append(f"{key}=[{len(val)}]")
+        else:
+            parts.append(f"{key}={val}")
+    return " ".join(parts)
+
+
+def _summarize_list(items: list[dict[str, Any]]) -> str:
+    """Compact list-view summary of an object array: the count, plus a grouped
+    state breakdown when the items carry a state-like field (e.g. instances).
+    Full per-item detail is available via the matching ``show`` command."""
+
+    n = len(items)
+    key = next(
+        (
+            k
+            for k in ("state_last_known", "state", "status", "phase")
+            if any(k in it for it in items)
+        ),
+        None,
+    )
+    if key is None:
+        return str(n)
+    counts: dict[str, int] = {}
+    for item in items:
+        value = str(item.get(key, ""))
+        counts[value] = counts.get(value, 0) + 1
+    if len(counts) == 1:
+        return f"{n} {next(iter(counts))}".strip()
+    return ", ".join(f"{count} {value}" for value, count in counts.items())
+
+
+def _cell(value: Any, *, compact: bool = False) -> str:
+    """Render a value for a table cell. ``compact`` (list views) collapses an
+    object array to a count summary; otherwise each item gets its own line."""
+
     if value is None:
         return ""
     if isinstance(value, bool):
         return "yes" if value else "no"
-    if isinstance(value, list) and not any(
-        isinstance(item, (dict, list)) for item in value
-    ):
-        return ", ".join(str(item) for item in value)
-    if isinstance(value, (dict, list)):
+    if isinstance(value, dict):
+        return _summarize_item(value)
+    if isinstance(value, list):
+        if not value:
+            return ""
+        if all(isinstance(item, dict) for item in value):
+            # a list of objects (instances, mailboxes, ips, ...): a count
+            # summary in lists, one line per item in detail views.
+            if compact:
+                return _summarize_list(value)
+            return "\n".join(_summarize_item(item) for item in value)
+        if not any(isinstance(item, (dict, list)) for item in value):
+            return ", ".join(str(item) for item in value)
         return json.dumps(value)
     return str(value)
 
@@ -244,15 +303,86 @@ def _flatten_row(row: dict[str, Any]) -> dict[str, Any]:
     return flat
 
 
+def _is_object_list(value: Any) -> bool:
+    return (
+        isinstance(value, list)
+        and len(value) > 0
+        and all(isinstance(item, dict) for item in value)
+    )
+
+
+def _object_table(items: list[dict[str, Any]]) -> Table:
+    """A compact sub-table for an array of objects, used inside the detail
+    view so nested data (instances, mailboxes, ips, ...) reads as a table
+    rather than one long line."""
+
+    cols = _auto_columns(items)
+    if not cols:  # all columns dropped (e.g. identical rows): show everything
+        cols = list(dict.fromkeys(key for item in items for key in item))
+    table = Table(box=box.SIMPLE_HEAD, show_header=True, pad_edge=False)
+    for col in cols:
+        table.add_column(col)
+    for item in items:
+        table.add_row(*(_cell(item.get(col), compact=True) for col in cols))
+    return table
+
+
 def _render_kv(data: dict[str, Any], title: str | None) -> None:
     table = Table(title=title, show_header=False)
     table.add_column(style="bold")
-    table.add_column()
+    table.add_column(overflow="fold")
     for key, value in _flatten_row(data).items():
-        table.add_row(key, _cell(value))
+        if value is None or value == "" or value == [] or value == {}:
+            continue  # drop empty fields so the detail view stays readable
+        cell: Any = _object_table(value) if _is_object_list(value) else _cell(value)
+        table.add_row(key, cell)
     out_console.print(table)
 
 
+def _auto_columns(rows: list[dict[str, Any]]) -> list[str]:
+    """Choose the columns worth showing in a list view, from the data itself.
+
+    Three things get dropped, because a list is an overview and the full record
+    is always available via the matching ``show`` command (or ``-o json``):
+
+    * columns empty in every row (no information at all);
+    * columns holding a list of objects (instances, mailboxes, ips, ...) -
+      these are detail, belonging in the ``show`` view, not the overview;
+    * columns whose value never changes across rows - they cost width without
+      helping tell the rows apart (the first column is kept as an anchor).
+    """
+
+    cols: list[str] = []
+    for row in rows:
+        if isinstance(row, dict):
+            for key in row:
+                if key not in cols:
+                    cols.append(key)
+
+    def empty(value: Any) -> bool:
+        return value is None or value == "" or value == [] or value == {}
+
+    def is_object_list(col: str) -> bool:
+        return any(
+            isinstance(row.get(col), list)
+            and row.get(col)
+            and all(isinstance(item, dict) for item in row[col])
+            for row in rows
+        )
+
+    cols = [
+        c
+        for c in cols
+        if any(not empty(row.get(c)) for row in rows) and not is_object_list(c)
+    ]
+    if len(rows) > 1 and cols:
+        anchor = cols[0]
+        rendered = {c: {_cell(row.get(c)) for row in rows} for c in cols}
+        if any(len(values) > 1 for values in rendered.values()):
+            cols = [c for c in cols if c == anchor or len(rendered[c]) > 1]
+    return cols
+
+
 def _render_rows(
     rows: list[dict[str, Any]], columns: list[str] | None, title: str | None
 ) -> None:
@@ -260,12 +390,12 @@ def _render_rows(
         err_console.print("[dim]no results[/]")
         return
     rows = [_flatten_row(row) if isinstance(row, dict) else row for row in rows]
-    cols = columns or list(rows[0].keys())
+    cols = columns if columns is not None else _auto_columns(rows)
     table = Table(title=title)
     for col in cols:
         table.add_column(col)
     for row in rows:
-        table.add_row(*(_cell(row.get(col)) for col in cols))
+        table.add_row(*(_cell(row.get(col), compact=True) for col in cols))
     out_console.print(table)
 
 

{devnomads_cli-0.5.1 → devnomads_cli-0.5.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "devnomads-cli"
-version = "0.5.1"
+version = "0.5.3"
 description = "Manage your DevNomads services from the command line"
 readme = "README.md"
 requires-python = ">=3.10"

{devnomads_cli-0.5.1 → devnomads_cli-0.5.3}/tests/test_helpers.py

@@ -4,9 +4,12 @@ import pytest
 
 from dncli import (
     CliError,
+    _auto_columns,
     _cell,
     _flatten_row,
+    _is_object_list,
     _mask,
+    _object_table,
     _unwrap,
     build_rrset,
     flatten_rrsets,
@@ -167,11 +170,119 @@ def test_cell():
     assert _cell(True) == "yes"
     assert _cell(False) == "no"
     assert _cell(42) == "42"
-    assert _cell({"a": 1}) == '{"a": 1}'
-    # scalar lists read as comma-separated values, nested ones stay JSON
+    # a bare object renders as a compact key=value summary
+    assert _cell({"a": 1}) == "a=1"
+    # scalar lists read as comma-separated values
     assert _cell(["instance_7:80", "instance_8:80"]) == "instance_7:80, instance_8:80"
     assert _cell([]) == ""
-    assert _cell([{"a": 1}]) == '[{"a": 1}]'
+
+
+def test_cell_list_of_objects_is_summarized():
+    # one readable line per item, not a raw JSON blob
+    ips = [
+        {"type": "v4", "address": "185.223.163.238"},
+        {"type": "v6", "address": "2a10:8c80:0:138::1"},
+    ]
+    assert _cell(ips) == (
+        "type=v4 address=185.223.163.238\ntype=v6 address=2a10:8c80:0:138::1"
+    )
+
+
+def test_cell_summary_drops_empty_and_counts_nested():
+    item = {
+        "id": 7,
+        "image": "geleijn-it/website",
+        "ended_at": None,
+        "has_pending_changes": 0,
+        "volumes": [{"id": 10}],
+        "meta": {},
+    }
+    # None dropped, 0 kept, non-empty nested list shown as a count, empty dict dropped
+    assert (
+        _cell([item])
+        == "id=7 image=geleijn-it/website has_pending_changes=0 volumes=[1]"
+    )
+
+
+def test_cell_mixed_list_stays_json():
+    assert _cell([{"a": 1}, "scalar"]) == '[{"a": 1}, "scalar"]'
+
+
+def test_cell_compact_summarizes_object_list_with_state():
+    # list view: count + grouped state, full detail lives in `show`
+    insts = [
+        {"id": 7, "state_last_known": "running"},
+        {"id": 8, "state_last_known": "running"},
+        {"id": 9, "state_last_known": "nostate"},
+    ]
+    assert _cell(insts, compact=True) == "2 running, 1 nostate"
+    same = [{"state_last_known": "running"}] * 3
+    assert _cell(same, compact=True) == "3 running"
+
+
+def test_cell_compact_without_state_is_just_count():
+    ips = [{"type": "v4", "address": "1.2.3.4"}, {"type": "v6", "address": "::1"}]
+    assert _cell(ips, compact=True) == "2"
+
+
+def test_cell_detail_keeps_per_item_lines():
+    # default (compact=False, used by `show`) still lists every item
+    insts = [{"id": 7, "state_last_known": "running"}]
+    assert _cell(insts) == "id=7 state_last_known=running"
+
+
+def test_auto_columns_drops_empty_constant_and_object_lists():
+    rows = [
+        {"id": 1, "port": 80, "registry": "same", "blank": "", "instances": [{"i": 7}]},
+        {"id": 2, "port": 81, "registry": "same", "blank": "", "instances": [{"i": 8}]},
+    ]
+    # registry is constant, blank is empty, instances is an object list -> all
+    # dropped; id (anchor) and port (varies) remain.
+    assert _auto_columns(rows) == ["id", "port"]
+
+
+def test_auto_columns_keeps_anchor_even_if_constant():
+    rows = [{"id": 1, "x": 9, "y": "a"}, {"id": 1, "x": 9, "y": "b"}]
+    # x is constant -> dropped; id is constant but the anchor -> kept
+    assert _auto_columns(rows) == ["id", "y"]
+
+
+def test_auto_columns_single_row_keeps_nonempty_scalars():
+    rows = [{"id": 1, "name": "x", "blank": None, "items": [{"a": 1}]}]
+    # one row: no constant-drop, but empty and object-list columns still go
+    assert _auto_columns(rows) == ["id", "name"]
+
+
+def test_is_object_list():
+    assert _is_object_list([{"a": 1}]) is True
+    assert _is_object_list([1, 2]) is False
+    assert _is_object_list([]) is False
+    assert _is_object_list("x") is False
+
+
+def test_object_table_uses_auto_columns():
+    items = [
+        {"emailaddress": "a@x", "quota": 1, "domain": "x"},
+        {"emailaddress": "b@x", "quota": 2, "domain": "x"},
+    ]
+    table = _object_table(items)
+    # constant `domain` dropped; the differing fields are kept as headers
+    assert [c.header for c in table.columns] == ["emailaddress", "quota"]
+
+
+def test_render_kv_drops_empty_and_nests_objects(capsys):
+    from dncli import AppState, OutputFormat, render
+
+    data = {
+        "id": 1,
+        "ended_at": None,
+        "note": "",
+        "ips": [{"type": "v4", "address": "10.0.0.1"}],
+    }
+    render(AppState(output=OutputFormat.table), data, title="srv")
+    out = capsys.readouterr().out
+    assert "ended_at" not in out and "note" not in out  # empty fields dropped
+    assert "ips" in out and "10.0.0.1" in out  # object array rendered
 
 
 def test_flatten_row_merges_nested_objects():