netbox-super-cli 1.2.0__tar.gz → 1.2.1__tar.gz

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/CHANGELOG.md

@@ -2,6 +2,27 @@
 
 All notable changes to netbox-super-cli are tracked here. Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) loosely. From v1.0.0 onward, releases follow [Semantic Versioning](https://semver.org/) and the version in `pyproject.toml` matches the git tag. Pre-1.0 milestones (Phase 1-5) were pinned by tag while `pyproject.toml` stayed at `0.0.1`.
 
+## v1.2.1 — 2026-06-25
+
+Patch release. Fixes foreign-key handling in the interactive TUI.
+
+### Fixed
+
+- **TUI foreign-key fields show names and a chooser, not raw IDs** ([#97]).
+  In the bulk-edit, single-edit and detail screens, FK fields (device `role`,
+  `site`, `tenant`, `device_type`, …) now render their human-readable
+  `display`/`name` in the confirmation diff and present a searchable
+  record-picker dropdown of valid related objects, instead of showing the
+  numeric id and requiring a raw id to be typed. The outgoing `PATCH` still
+  carries the id, so the wire format is unchanged. FK detection is now keyed on
+  the record's nested object rather than the widget kind, because NetBox's
+  writable schema types FK fields as `oneOf[integer, brief]` (no primitive
+  type), which previously fell through to a free-text widget. When a relation's
+  target resource has no list endpoint, the field gracefully falls back to
+  raw-id entry with a hint rather than an inert chooser button.
+
+[#97]: https://github.com/thomaschristory/netbox-super-cli/issues/97
+
 ## v1.2.0 — 2026-06-24
 
 Minor release. Adds an **interactive terminal UI** — a keyboard-driven, fully

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: netbox-super-cli
-Version: 1.2.0
+Version: 1.2.1
 Summary: Dynamic NetBox CLI generated from the live OpenAPI schema.
 Project-URL: Homepage, https://github.com/thomaschristory/netbox-super-cli
 Project-URL: Issues, https://github.com/thomaschristory/netbox-super-cli/issues

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/_version.py

@@ -1,3 +1,3 @@
 """Single source of truth for the package version."""
 
-__version__ = "1.2.0"
+__version__ = "1.2.1"

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/tui/bulk.py

@@ -28,17 +28,20 @@ def bulk_diff(
     selected: list[dict[str, object]],
     bulk_set: dict[str, object],
     sensitive_paths: tuple[str, ...],
+    new_displays: dict[str, str] | None = None,
 ) -> list[RecordChange]:
     """Compute the per-record patch and diff rows for a uniform bulk ``set``.
 
     Order of ``selected`` is preserved. A field whose new value equals a
     record's current value contributes no patch entry and no row for that
     record, so heterogeneous current values yield different changed subsets.
+    ``new_displays`` maps a field to the human label of its chosen FK value so
+    the diff renders the name rather than the id.
     """
     changes: list[RecordChange] = []
     for record in selected:
         patch = compute_patch(record, bulk_set)
-        rows = diff_rows(record, patch, sensitive_paths)
+        rows = diff_rows(record, patch, sensitive_paths, new_displays)
         changes.append(RecordChange(record_id=record.get("id"), patch=patch, rows=rows))
     return changes
 

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/tui/fk.py

@@ -28,6 +28,17 @@ FkKind = Literal["picker", "raw_id"]
 _MIN_URL_SEGMENTS = 2
 
 
+def is_fk_value(value: Any) -> bool:
+    """True when ``value`` is a NetBox FK nested object (carries ``id``/``url``).
+
+    The writable schema types FK fields as ``oneOf[integer, brief-ref]`` with no
+    top-level ``type``, so the model has no FK signal; the reliable runtime cue
+    is the record's nested object. A bare ``custom_fields`` dict (no id/url) is
+    deliberately excluded.
+    """
+    return isinstance(value, dict) and ("id" in value or "url" in value)
+
+
 class FkTarget(BaseModel):
     model_config = ConfigDict(frozen=True, extra="forbid")
 
@@ -79,6 +90,16 @@ def _resolve_from_url(field_name: str, current_value: Any, model: CommandModel)
         )
 
     tag, list_op = located
+    # A `picker` target must carry a usable list endpoint — otherwise the screen
+    # renders a chooser button that can't open anything. Resolvable but
+    # list-less resources fall back to raw-ID entry, like an unknown resource.
+    if list_op is None:
+        return FkTarget(
+            kind="raw_id",
+            field_name=field_name,
+            current_id=current_id,
+            hint=(f"'{resource_name}' has no list endpoint; enter the numeric ID."),
+        )
     return FkTarget(
         kind="picker",
         field_name=field_name,

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/tui/forms.py

@@ -87,8 +87,18 @@ def compute_patch(original: dict[str, object], staged: dict[str, object]) -> dic
     return patch
 
 
-def _display(value: object) -> str:
+def fk_display(value: object) -> str:
+    """Human-readable label for a value, resolving FK nested objects.
+
+    NetBox FK objects carry ``display`` (and usually ``name``/``slug``); prefer
+    those over the bare ``id`` so the diff shows e.g. ``Top of Rack Switch``
+    rather than ``12``. Non-dict values render via ``str``.
+    """
     if isinstance(value, dict):
+        for key in ("display", "name", "slug"):
+            label = value.get(key)
+            if label:
+                return str(label)
         ident = value.get("id")
         if ident is not None:
             return str(ident)
@@ -99,13 +109,21 @@ def diff_rows(
     original: dict[str, object],
     patch: dict[str, object],
     sensitive_paths: tuple[str, ...],
+    new_displays: dict[str, str] | None = None,
 ) -> list[DiffRow]:
-    """Render ``patch`` as human-readable old -> new rows for the confirm modal."""
+    """Render ``patch`` as human-readable old -> new rows for the confirm modal.
+
+    ``new_displays`` overrides a field's rendered *new* value — used for FK
+    fields whose staged value is a bare id but whose chosen label is known
+    (e.g. picked from the record chooser). The patch still carries the id.
+    """
+    overrides = new_displays or {}
     rows: list[DiffRow] = []
     for name, new_value in patch.items():
         if name in sensitive_paths:
             rows.append(DiffRow(field=name, old_display="****", new_display="****"))
             continue
-        old_display = _display(original[name]) if name in original else ""
-        rows.append(DiffRow(field=name, old_display=old_display, new_display=str(new_value)))
+        old_display = fk_display(original[name]) if name in original else ""
+        new_display = overrides.get(name, str(new_value))
+        rows.append(DiffRow(field=name, old_display=old_display, new_display=new_display))
     return rows

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/tui/screens/bulk_edit_form.py

@@ -21,9 +21,14 @@ from textual.widgets import Button, Footer, Header, Input, Label, ProgressBar, S
 from nsc.model.command_model import CommandModel, Operation
 from nsc.tui._bindings import textual_bindings
 from nsc.tui.bulk import RecordChange, shared_values
-from nsc.tui.forms import SET_NULL, WidgetSpec, field_to_widget
+from nsc.tui.fk import is_fk_value, resolve_fk_target
+from nsc.tui.forms import SET_NULL, WidgetSpec, field_to_widget, fk_display
 from nsc.tui.view import detail_path
 
+# Sentinel: a picker FK opted in with neither a pick nor a shared value
+# contributes nothing, so it never nulls the relation.
+_NO_SEED = object()
+
 
 class _Client(Protocol):
     def paginate(
@@ -62,6 +67,8 @@ class BulkEditForm(Screen[None]):
         self._specs: dict[str, WidgetSpec] = {}
         self._values: dict[str, Any] = {}
         self._included: set[str] = set()
+        self._fk_kinds: dict[str, str] = {}
+        self._fk_labels: dict[str, str] = {}
         body = update_op.request_body
         field_names = list(body.fields) if body is not None else []
         # Shared current value per field, to seed the widgets (does NOT opt the
@@ -99,7 +106,47 @@ class BulkEditForm(Screen[None]):
             if spec.nullable:
                 yield Button("∅", id=f"setnull-{name}", classes="bulk-setnull")
 
+    def _is_fk(self, name: str, spec: WidgetSpec) -> bool:
+        if spec.kind in ("select", "switch", "masked") or spec.is_float:
+            return False
+        return name.endswith("_id") or any(
+            is_fk_value(record.get(name)) for record in self._selected
+        )
+
+    def _fk_nested_value(self, name: str) -> Any:
+        """A representative nested FK object across the selection, for resolution."""
+        for record in self._selected:
+            value = record.get(name)
+            if is_fk_value(value):
+                return value
+        return None
+
+    def _fk_seed_label(self, name: str) -> str:
+        shared_id = self._shared.get(name)
+        if shared_id is None:
+            return ""
+        for record in self._selected:
+            value = record.get(name)
+            if isinstance(value, dict) and value.get("id") == shared_id:
+                return fk_display(value)
+        return str(shared_id)
+
+    def _compose_fk(self, name: str) -> ComposeResult:
+        target = resolve_fk_target(name, self._fk_nested_value(name), self._model)
+        self._fk_kinds[name] = target.kind
+        shared_id = self._shared.get(name)
+        if target.kind == "raw_id":
+            text = "" if shared_id is None else str(shared_id)
+            yield Input(value=text, id=f"field-{name}")
+            if target.hint:
+                yield Label(target.hint, classes="bulk-fk-hint")
+            return
+        yield Button(f"{name}: {self._fk_seed_label(name)}", id=f"fk-{name}", classes="bulk-fk")
+
     def _compose_widget(self, name: str, spec: WidgetSpec) -> ComposeResult:
+        if self._is_fk(name, spec):
+            yield from self._compose_fk(name)
+            return
         shared = self._shared.get(name)
         if spec.kind == "select":
             options = [(choice, choice) for choice in spec.choices]
@@ -126,12 +173,15 @@ class BulkEditForm(Screen[None]):
 
     def _coerce_input(self, name: str, raw: str) -> Any:
         spec = self._specs.get(name)
-        if spec is None or spec.kind != "number":
+        numeric = (spec is not None and spec.kind == "number") or self._fk_kinds.get(
+            name
+        ) == "raw_id"
+        if not numeric:
             return raw
         if raw == "":
             return None
         try:
-            return float(raw) if spec.is_float else int(raw)
+            return float(raw) if spec is not None and spec.is_float else int(raw)
         except ValueError:
             return raw
 
@@ -140,7 +190,10 @@ class BulkEditForm(Screen[None]):
         if include is not None:
             if event.value:
                 self._included.add(include)
-                self._values.setdefault(include, self._read_widget_value(include))
+                if include not in self._values:
+                    seed = self._read_widget_value(include)
+                    if seed is not _NO_SEED:
+                        self._values[include] = seed
             else:
                 self._included.discard(include)
             return
@@ -150,6 +203,9 @@ class BulkEditForm(Screen[None]):
 
     def _read_widget_value(self, name: str) -> Any:
         spec = self._specs.get(name)
+        if self._fk_kinds.get(name) == "picker":
+            shared_id = self._shared.get(name)
+            return shared_id if shared_id is not None else _NO_SEED
         if spec is not None and spec.kind == "select":
             value = self.query_one(f"#field-{name}", Select).value
             return None if value is Select.NULL else value
@@ -173,6 +229,27 @@ class BulkEditForm(Screen[None]):
         name = self._strip(ident, "setnull-")
         if name is not None:
             self._values[name] = SET_NULL
+            # Drop any picked label so the diff can't show a name while the
+            # patch nulls the relation.
+            self._fk_labels.pop(name, None)
+            return
+        fk = self._strip(ident, "fk-")
+        if fk is not None:
+            self._open_picker(fk)
+
+    def _open_picker(self, name: str) -> None:
+        target = resolve_fk_target(name, self._fk_nested_value(name), self._model)
+        if target.list_op is None:
+            return
+        from nsc.tui.screens.record_picker import RecordPicker  # noqa: PLC0415
+
+        def _stage(result: tuple[int, str] | None) -> None:
+            if result is not None:
+                self._values[name] = result[0]
+                self._fk_labels[name] = result[1]
+                self.query_one(f"#fk-{name}", Button).label = f"{name}: {result[1]}"
+
+        self.app.push_screen(RecordPicker(self._client, target.list_op, target.current_id), _stage)
 
     def action_preview(self) -> None:
         from nsc.tui.bulk import bulk_diff  # noqa: PLC0415
@@ -180,7 +257,7 @@ class BulkEditForm(Screen[None]):
 
         body = self._op.request_body
         sensitive = body.sensitive_paths if body is not None else ()
-        changes = bulk_diff(self._selected, self.bulk_set, sensitive)
+        changes = bulk_diff(self._selected, self.bulk_set, sensitive, self._fk_labels)
 
         def _on_confirm(confirmed: bool | None) -> None:
             if confirmed:

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/tui/screens/detail.py

@@ -23,7 +23,7 @@ from nsc.model.command_model import CommandModel, Resource
 from nsc.output.flatten import flatten
 from nsc.tui._bindings import textual_bindings
 from nsc.tui.errors import api_error_message
-from nsc.tui.fk import resolve_fk_target
+from nsc.tui.fk import is_fk_value, resolve_fk_target
 from nsc.tui.forms import SET_NULL, WidgetSpec, compute_patch, diff_rows, field_to_widget
 from nsc.tui.relations import RelatedView, related_views
 from nsc.tui.view import detail_path
@@ -69,6 +69,7 @@ class DetailScreen(Screen[None]):
         self._specs: dict[str, WidgetSpec] = {}
         self._rows: list[_FieldRow] = []
         self.staged: dict[str, Any] = {}
+        self._fk_labels: dict[str, str] = {}
         self._editing: str | None = None
         self._relations: list[RelatedView] = related_views(model, resource_name)
         self.title = f"{resource_name} #{record.get('id', '?')}"
@@ -129,8 +130,11 @@ class DetailScreen(Screen[None]):
             staged = self.staged[row.name]
             if staged is SET_NULL:
                 return "(null)"
-            # Never echo a just-typed secret back into the on-screen table.
-            return "****" if sensitive and staged != "" else str(staged)
+            # Never echo a just-typed secret; a picked FK stages a bare id, so
+            # show its chosen label rather than the number.
+            return (
+                "****" if sensitive and staged != "" else self._fk_labels.get(row.name, str(staged))
+            )
         if row.editable:
             value = self._record.get(row.name)
             if isinstance(value, dict):
@@ -199,6 +203,7 @@ class DetailScreen(Screen[None]):
         def _stage(result: tuple[int, str] | None) -> None:
             if result is not None:
                 self.staged[name] = result[0]
+                self._fk_labels[name] = result[1]
                 self._refresh_rows()
 
         self.app.push_screen(RecordPicker(self._client, target.list_op, target.current_id), _stage)
@@ -236,9 +241,12 @@ class DetailScreen(Screen[None]):
         self._table.focus()
 
     def _is_fk(self, name: str, spec: WidgetSpec) -> bool:
-        if spec.kind != "number" or spec.is_float or spec.sensitive:
+        # Writable FK fields type as oneOf[int, brief] -> UNKNOWN -> `text`, so a
+        # `number`-only gate would miss real relations. Key off the record's
+        # nested object instead; exclude enum/bool/secret/float.
+        if spec.kind in ("select", "switch", "masked") or spec.is_float:
             return False
-        return name.endswith("_id") or isinstance(self._record.get(name), dict)
+        return name.endswith("_id") or is_fk_value(self._record.get(name))
 
     # --- save ------------------------------------------------------------
     def action_save_all(self) -> None:
@@ -254,7 +262,7 @@ class DetailScreen(Screen[None]):
             if confirmed:
                 self._apply_patch(patch)
 
-        rows = diff_rows(self._record, patch, self._sensitive)
+        rows = diff_rows(self._record, patch, self._sensitive, self._fk_labels)
         self.app.push_screen(DiffModal(rows), _on_confirm)
 
     def _apply_patch(self, patch: dict[str, Any]) -> None:

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/nsc/tui/screens/edit_form.py

@@ -19,8 +19,15 @@ from nsc.http.errors import NetBoxAPIError, NetBoxClientError
 from nsc.model.command_model import CommandModel, Operation
 from nsc.tui._bindings import textual_bindings
 from nsc.tui.errors import api_error_message
-from nsc.tui.fk import resolve_fk_target
-from nsc.tui.forms import SET_NULL, WidgetSpec, compute_patch, diff_rows, field_to_widget
+from nsc.tui.fk import is_fk_value, resolve_fk_target
+from nsc.tui.forms import (
+    SET_NULL,
+    WidgetSpec,
+    compute_patch,
+    diff_rows,
+    field_to_widget,
+    fk_display,
+)
 from nsc.tui.view import detail_path
 
 
@@ -75,6 +82,7 @@ class EditForm(Screen[None]):
         self._op = operation
         self._record = record
         self._specs: dict[str, WidgetSpec] = {}
+        self._fk_labels: dict[str, str] = {}
         self.staged: dict[str, Any] = {}
         self._create_mode = operation.http_method.upper() == "POST"
         if self._create_mode:
@@ -119,9 +127,12 @@ class EditForm(Screen[None]):
         yield Input(value=text, password=spec.sensitive, id=f"field-{name}")
 
     def _is_fk(self, name: str, spec: WidgetSpec) -> bool:
-        if spec.kind != "number" or spec.is_float or spec.sensitive:
+        # Writable FK fields type as oneOf[int, brief] -> UNKNOWN -> `text`, so a
+        # `number`-only gate would miss real relations (role, site, tenant…). Key
+        # off the record's nested object instead; exclude enum/bool/secret/float.
+        if spec.kind in ("select", "switch", "masked") or spec.is_float:
             return False
-        return name.endswith("_id") or isinstance(self._record.get(name), dict)
+        return name.endswith("_id") or is_fk_value(self._record.get(name))
 
     def _compose_fk(self, name: str, value: Any) -> ComposeResult:
         target = resolve_fk_target(name, self._record.get(name), self._model)
@@ -131,7 +142,12 @@ class EditForm(Screen[None]):
             if target.hint:
                 yield Label(target.hint, classes="edit-fk-hint")
             return
-        current = "" if value is None else str(value)
+        nested = self._record.get(name)
+        current = (
+            fk_display(nested)
+            if isinstance(nested, dict)
+            else ("" if value is None else str(value))
+        )
         yield Button(f"{name}: {current}", id=f"fk-{name}", classes="edit-fk")
 
     @staticmethod
@@ -181,7 +197,10 @@ class EditForm(Screen[None]):
             self.action_save()
             return
         if ident.startswith("setnull-"):
-            self.staged[ident.removeprefix("setnull-")] = SET_NULL
+            field = ident.removeprefix("setnull-")
+            self.staged[field] = SET_NULL
+            # Drop any picked label so the diff can't show a name while nulling.
+            self._fk_labels.pop(field, None)
             return
         if ident.startswith("fk-"):
             self._open_picker(ident.removeprefix("fk-"))
@@ -195,6 +214,7 @@ class EditForm(Screen[None]):
         def _stage(result: tuple[int, str] | None) -> None:
             if result is not None:
                 self.staged[name] = result[0]
+                self._fk_labels[name] = result[1]
                 self.query_one(f"#fk-{name}", Button).label = f"{name}: {result[1]}"
 
         self.app.push_screen(RecordPicker(self._client, target.list_op, target.current_id), _stage)
@@ -212,7 +232,9 @@ class EditForm(Screen[None]):
             if confirmed:
                 self._apply_patch(patch, sensitive)
 
-        self.app.push_screen(DiffModal(diff_rows(self._record, patch, sensitive)), _on_confirm)
+        self.app.push_screen(
+            DiffModal(diff_rows(self._record, patch, sensitive, self._fk_labels)), _on_confirm
+        )
 
     def _apply_patch(self, patch: dict[str, Any], sensitive_paths: tuple[str, ...]) -> None:
         try:

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "netbox-super-cli"
-version = "1.2.0"
+version = "1.2.1"
 description = "Dynamic NetBox CLI generated from the live OpenAPI schema."
 readme = "README.md"
 requires-python = ">=3.12"

{netbox_super_cli-1.2.0 → netbox_super_cli-1.2.1}/tests/tui/test_bulk_diff.py

@@ -78,7 +78,15 @@ def test_fk_nested_dict_by_id_changes_when_id_differs() -> None:
     selected = [{"id": 1, "site": {"id": 9, "name": "dc1"}}]
     result = bulk_diff(selected, {"site": 3}, ())
     assert result[0].patch == {"site": 3}
-    assert result[0].rows == [DiffRow(field="site", old_display="9", new_display="3")]
+    # Old value renders the FK's human label, not its numeric id.
+    assert result[0].rows == [DiffRow(field="site", old_display="dc1", new_display="3")]
+
+
+def test_fk_new_display_override_renders_chosen_label() -> None:
+    selected = [{"id": 1, "site": {"id": 9, "name": "dc1"}}]
+    result = bulk_diff(selected, {"site": 3}, (), {"site": "dc2"})
+    assert result[0].patch == {"site": 3}
+    assert result[0].rows == [DiffRow(field="site", old_display="dc1", new_display="dc2")]
 
 
 def test_set_null_on_already_null_record_yields_no_row() -> None: