Improved menu

Author: DOKOS-TAYOS

scripts/verify.py

@@ -44,9 +44,7 @@ def _command_groups() -> dict[str, VerificationGroup]:
                 ),
             ),
         ),
-        "package": (
-            VerificationStep("build-dist", (python, "-m", "build", "--sdist", "--wheel")),
-        ),
+        "package": (VerificationStep("build-dist", (python, "-m", "build", "--sdist", "--wheel")),),
     }
 
 

src/tensor_network_viz/_core/renderer.py

@@ -35,6 +35,9 @@
 RenderedAxes: TypeAlias = Axes | Axes3D
 _Dimensions = Literal[2, 3]
 _LayoutCacheKey: TypeAlias = tuple[int, int, int]
+# Main axes: use almost the full figure width (interactive widgets sit in the bottom margin).
+_FIGURE_ADJUST_LEFT: float = 0.006
+_FIGURE_ADJUST_RIGHT: float = 0.994
 
 _layout_positions_by_id: dict[
     int,
@@ -423,7 +426,12 @@ def _plot_graph(
         build_scene_state=build_scene_state,
     )
     reserved_bottom = get_reserved_bottom(fig)
-    fig.subplots_adjust(left=0.02, right=0.98, bottom=reserved_bottom, top=0.98)
+    fig.subplots_adjust(
+        left=_FIGURE_ADJUST_LEFT,
+        right=_FIGURE_ADJUST_RIGHT,
+        bottom=reserved_bottom,
+        top=0.98,
+    )
     return fig, resolved_ax
 
 

src/tensor_network_viz/_tensor_elements_data.py

@@ -51,6 +51,7 @@ class _EinsumPlaybackStepRecord:
     result_name: str
     record: _TensorRecord | None
 
+
 def _detect_tensor_elements_engine(data: Any) -> tuple[EngineName, Any]:
     return _detect_tensor_engine_with_input(data)
 

src/tensor_network_viz/_ui_utils.py

@@ -15,6 +15,14 @@ def _reserve_figure_bottom(fig: Figure, bottom: float) -> None:
     fig.subplots_adjust(bottom=target)
 
 
+def _set_figure_bottom_reserved(fig: Figure, bottom: float) -> None:
+    """Store and apply *bottom*; unlike `_reserve_figure_bottom`, can shrink the reserved strip."""
+    b = float(bottom)
+    set_reserved_bottom(fig, b)
+    p = fig.subplotpars
+    fig.subplots_adjust(left=p.left, right=p.right, top=p.top, bottom=b)
+
+
 def _set_axes_visible(ax: Any, visible: bool) -> None:
     ax.set_visible(visible)
     ax.patch.set_visible(visible)
@@ -32,4 +40,9 @@ def _set_widget_active(widget: Any, active: bool) -> None:
             setter(bool(active))
 
 
-__all__ = ["_reserve_figure_bottom", "_set_axes_visible", "_set_widget_active"]
+__all__ = [
+    "_reserve_figure_bottom",
+    "_set_figure_bottom_reserved",
+    "_set_axes_visible",
+    "_set_widget_active",
+]

src/tensor_network_viz/contraction_viewer.py

@@ -40,17 +40,41 @@
 _TNV_CONTRACTION_SCHEME_PATCH_GID: Final[str] = "tnv_contraction_scheme"
 
 _TRANSPARENT: tuple[float, float, float, float] = (0.0, 0.0, 0.0, 0.0)
-_PLAYBACK_MAIN_BOTTOM: float = 0.40
 _PLAYBACK_DETAILS_BOUNDS: tuple[float, float, float, float] = (0.25, 0.116, 0.68, 0.12)
-_PLAYBACK_SLIDER_BOUNDS: tuple[float, float, float, float] = (0.33, 0.067, 0.345, 0.024)
+# Top of the cost / step-details axis; interactive chrome (checkboxes, 2d/3d) aligns to this y.
+_PLAYBACK_DETAILS_TOP: float = _PLAYBACK_DETAILS_BOUNDS[1] + _PLAYBACK_DETAILS_BOUNDS[3]
+# Aligned with the top of the cost / scheme chrome (no extra gap above the widgets).
+_MAIN_FIGURE_BOTTOM_RESERVED: float = _PLAYBACK_DETAILS_TOP
+_PLAYBACK_MAIN_BOTTOM: float = _MAIN_FIGURE_BOTTOM_RESERVED
+_CONTROLS_MAIN_BOTTOM: float = _MAIN_FIGURE_BOTTOM_RESERVED
+_PLAYBACK_SLIDER_HEIGHT: float = 0.058
+_PLAYBACK_SLIDER_BOUNDS: tuple[float, float, float, float] = (
+    0.33,
+    0.062,
+    0.345,
+    _PLAYBACK_SLIDER_HEIGHT,
+)
+_PLAYBACK_SLIDER_HANDLE_STYLE: dict[str, Any] = {
+    "facecolor": "#2563eb",
+    "edgecolor": "#1d4ed8",
+    "size": 11,
+}
 _PLAYBACK_BUTTON_START_X: float = 0.73
 _PLAYBACK_BUTTON_Y: float = 0.058
 _PLAYBACK_BUTTON_WIDTH: float = 0.055
 _PLAYBACK_BUTTON_HEIGHT: float = 0.038
 _PLAYBACK_BUTTON_GAP: float = 0.012
 _PLAYBACK_RESET_WIDTH: float = 0.065
-_CONTROLS_MAIN_BOTTOM: float = _PLAYBACK_MAIN_BOTTOM
-_CONTROLS_CHECKBOX_BOUNDS: tuple[float, float, float, float] = (0.02, 0.045, 0.13, 0.10)
+_CONTROLS_CHECKBOX_TOP: float = _PLAYBACK_DETAILS_TOP
+_CONTROLS_CHECKBOX_HEIGHT: float = 0.10
+_CONTROLS_CHECKBOX_BOUNDS: tuple[float, float, float, float] = (
+    0.02,
+    _CONTROLS_CHECKBOX_TOP - _CONTROLS_CHECKBOX_HEIGHT,
+    0.13,
+    _CONTROLS_CHECKBOX_HEIGHT,
+)
+_PLAYBACK_TRAY_FACE: tuple[float, float, float] = (0.96, 0.96, 0.98)
+_PLAYBACK_TRAY_FRAME: tuple[float, float, float] = (0.78, 0.78, 0.82)
 _SCHEME_LABELS: tuple[str, str, str] = ("Scheme", "Playback", "Costs")
 _CONTROL_LABEL_PROPS: dict[str, Sequence[Any]] = {"fontsize": [9.5]}
 _CONTROL_FRAME_PROPS: dict[str, float] = {"s": 44.0, "linewidth": 0.9}
@@ -452,9 +476,15 @@ def _build_step_details_panel(self) -> None:
         ax_details = self.figure.add_axes(_PLAYBACK_DETAILS_BOUNDS)
         ax_details.set_xticks([])
         ax_details.set_yticks([])
-        ax_details.patch.set_alpha(0.0)
+        ax_details.set_navigate(False)
+        ax_details.patch.set_facecolor(_PLAYBACK_TRAY_FACE)
+        ax_details.patch.set_alpha(0.92)
+        ax_details.patch.set_edgecolor(_PLAYBACK_TRAY_FRAME)
+        ax_details.patch.set_linewidth(0.6)
         for spine in ax_details.spines.values():
-            spine.set_visible(False)
+            spine.set_visible(True)
+            spine.set_linewidth(0.6)
+            spine.set_color(_PLAYBACK_TRAY_FRAME)
         text = ax_details.text(
             0.0,
             1.0,
@@ -507,6 +537,7 @@ def build_ui(self, *, initialize_step: bool = True) -> None:
             float(max(0, n)),
             valinit=float(self._initial_step if self._initial_step is not None else n),
             valstep=1,
+            handle_style=_PLAYBACK_SLIDER_HANDLE_STYLE,
         )
         self.slider = slider
 
@@ -687,6 +718,17 @@ def __init__(
 
     def _build_controls(self) -> None:
         controls_ax = self.figure.add_axes(_CONTROLS_CHECKBOX_BOUNDS)
+        controls_ax.set_xticks([])
+        controls_ax.set_yticks([])
+        controls_ax.set_navigate(False)
+        controls_ax.patch.set_facecolor((0.97, 0.97, 0.99))
+        controls_ax.patch.set_alpha(0.88)
+        controls_ax.patch.set_edgecolor(_PLAYBACK_TRAY_FRAME)
+        controls_ax.patch.set_linewidth(0.6)
+        for spine in controls_ax.spines.values():
+            spine.set_visible(True)
+            spine.set_linewidth(0.6)
+            spine.set_color(_PLAYBACK_TRAY_FRAME)
         self._controls_ax = controls_ax
         self._checkbuttons = CheckButtons(
             controls_ax,

src/tensor_network_viz/interactive_viewer.py

@@ -32,32 +32,61 @@
 )
 from ._tensor_elements_support import _TensorRecord
 from ._typing import root_figure
-from ._ui_utils import _reserve_figure_bottom, _set_axes_visible
+from ._ui_utils import _set_axes_visible, _set_figure_bottom_reserved
 from .config import EngineName, PlotConfig, ViewName
+from .contraction_viewer import _MAIN_FIGURE_BOTTOM_RESERVED, _PLAYBACK_DETAILS_TOP
 from .einsum_module.trace import EinsumTrace
 from .tensor_elements import _show_tensor_records
 from .tensor_elements_config import TensorElementsConfig
 
 RenderedAxes = Axes | Axes3D
 
-# 2d/3d: width 0.053 (= 60% of 0.088); height 0.063; bottom lowered ~0.03 vs earlier slider-row alignment.
-_VIEW_SELECTOR_BOUNDS: tuple[float, float, float, float] = (0.213, 0.025, 0.053, 0.063)
-_BASE_INTERACTIVE_CHECKBOX_BOUNDS: tuple[float, float, float, float] = (0.02, 0.028, 0.19, 0.09)
-_SCHEME_INTERACTIVE_CHECKBOX_BOUNDS: tuple[float, float, float, float] = (0.02, 0.028, 0.19, 0.142)
-_SCHEME_INSPECTOR_INTERACTIVE_CHECKBOX_BOUNDS: tuple[float, float, float, float] = (
+# Menu column: fixed bottom = tallest stack (inspector + scheme). Without playback, checkboxes/radio
+# stay as low as when the bottom row exists. Top aligned with cost-details top.
+_VIEW_SELECTOR_LEFT: float = 0.213
+_VIEW_SELECTOR_WIDTH: float = 0.053
+_VIEW_SELECTOR_HEIGHT: float = 0.063
+# Manual axes positions: 2D extends slightly below *base*, 3D starts higher (base + lift).
+_INTERACTIVE_2D_BOTTOM_EXTRA: float = 0.022
+_INTERACTIVE_3D_BOTTOM_LIFT: float = 0.084
+_BASE_INTERACTIVE_HEIGHT: float = 0.09
+_SCHEME_INSPECTOR_INTERACTIVE_HEIGHT: float = 0.172
+_INTERACTIVE_MENU_COLUMN_HEIGHT: float = _SCHEME_INSPECTOR_INTERACTIVE_HEIGHT
+_INTERACTIVE_MENU_COLUMN_BOTTOM: float = _PLAYBACK_DETAILS_TOP - _INTERACTIVE_MENU_COLUMN_HEIGHT
+_INTERACTIVE_CHECKBOX_AXES_BOUNDS: tuple[float, float, float, float] = (
     0.02,
-    0.028,
+    _INTERACTIVE_MENU_COLUMN_BOTTOM,
     0.19,
-    0.172,
+    _INTERACTIVE_MENU_COLUMN_HEIGHT,
+)
+# When Scheme is off, main axes bottom (not tied to menu column bottom after unifying menus).
+_SCHEME_OFF_FIGURE_BOTTOM_PAD: float = 0.02
+_MAIN_FIGURE_BOTTOM_SCHEME_OFF: float = (
+    _PLAYBACK_DETAILS_TOP - _BASE_INTERACTIVE_HEIGHT + _SCHEME_OFF_FIGURE_BOTTOM_PAD
 )
-_INTERACTIVE_CONTROLS_BOTTOM: float = 0.26
 _BASE_TOGGLE_LABELS: tuple[str, str, str] = ("Hover", "Tensor labels", "Edge labels")
 _SCHEME_TOGGLE_LABELS: tuple[str, str, str] = ("Scheme", "Playback", "Costs")
 _TENSOR_INSPECTOR_LABEL: str = "Tensor inspector"
 _INTERACTIVE_LABEL_PROPS: dict[str, Sequence[Any]] = {"fontsize": [9.5]}
 _INTERACTIVE_CHECK_FRAME_PROPS: dict[str, float] = {"s": 44.0, "linewidth": 0.9}
 _INTERACTIVE_CHECK_MARK_PROPS: dict[str, float] = {"s": 34.0, "linewidth": 1.0}
 _INTERACTIVE_RADIO_PROPS: dict[str, float] = {"s": 38.0, "linewidth": 0.9}
+_CONTROL_TRAY_FACE: tuple[float, float, float] = (0.97, 0.97, 0.99)
+_CONTROL_TRAY_FRAME: tuple[float, float, float] = (0.78, 0.78, 0.82)
+
+
+def _style_interactive_control_axes(ax: Axes) -> None:
+    ax.set_xticks([])
+    ax.set_yticks([])
+    ax.set_navigate(False)
+    ax.patch.set_facecolor(_CONTROL_TRAY_FACE)
+    ax.patch.set_alpha(0.88)
+    ax.patch.set_edgecolor(_CONTROL_TRAY_FRAME)
+    ax.patch.set_linewidth(0.6)
+    for spine in ax.spines.values():
+        spine.set_visible(True)
+        spine.set_linewidth(0.6)
+        spine.set_color(_CONTROL_TRAY_FRAME)
 
 
 @dataclass
@@ -222,11 +251,8 @@ def _interactive_checkbox_bounds(
     include_scheme_toggles: bool,
     include_tensor_inspector: bool,
 ) -> tuple[float, float, float, float]:
-    if include_scheme_toggles and include_tensor_inspector:
-        return _SCHEME_INSPECTOR_INTERACTIVE_CHECKBOX_BOUNDS
-    if include_scheme_toggles:
-        return _SCHEME_INTERACTIVE_CHECKBOX_BOUNDS
-    return _BASE_INTERACTIVE_CHECKBOX_BOUNDS
+    _ = include_scheme_toggles, include_tensor_inspector
+    return _INTERACTIVE_CHECKBOX_AXES_BOUNDS
 
 
 class _InteractiveTensorFigureController:
@@ -290,8 +316,6 @@ def initialize(self) -> tuple[Figure, RenderedAxes]:
         self.figure = figure
         if self._view_caches[self.current_view].scene is None:
             return figure, ax
-        if not self._external_ax:
-            _reserve_figure_bottom(figure, _INTERACTIVE_CONTROLS_BOTTOM)
         self._build_controls()
         self._apply_scene_state(self.current_scene)
         set_interactive_controls(figure, self)
@@ -346,6 +370,60 @@ def _build_view(
             scene.contraction_controls = get_contraction_controls(rendered_ax)
         return fig, rendered_ax
 
+    def _shared_data_axes_top(self) -> float:
+        ax3 = self._view_caches["3d"].ax
+        if ax3 is not None:
+            p = ax3.get_position()
+            return float(p.y0 + p.height)
+        ax2 = self._view_caches["2d"].ax
+        if ax2 is not None:
+            p = ax2.get_position()
+            return float(p.y0 + p.height)
+        return 0.9
+
+    def _interactive_scheme_chrome_on(self) -> bool:
+        return self.current_scene.contraction_controls is not None and self.scheme_on
+
+    def _interactive_main_axes_bottom(self) -> float:
+        return float(
+            _MAIN_FIGURE_BOTTOM_RESERVED
+            if self._interactive_scheme_chrome_on()
+            else _MAIN_FIGURE_BOTTOM_SCHEME_OFF
+        )
+
+    def _figure_bottom_margin(self) -> float:
+        base = self._interactive_main_axes_bottom()
+        lows: list[float] = []
+        if self._view_caches["2d"].ax is not None:
+            lows.append(base - float(_INTERACTIVE_2D_BOTTOM_EXTRA))
+        if self._view_caches["3d"].ax is not None:
+            lows.append(base + float(_INTERACTIVE_3D_BOTTOM_LIFT))
+        return min(lows) if lows else base
+
+    def _apply_interactive_figure_layout(self) -> None:
+        if self.figure is None or self._external_ax:
+            return
+        _set_figure_bottom_reserved(self.figure, self._figure_bottom_margin())
+        self._sync_data_axes_vertical_layout()
+
+    def _sync_data_axes_vertical_layout(self) -> None:
+        if self.figure is None or self._external_ax:
+            return
+        base = self._interactive_main_axes_bottom()
+        top = self._shared_data_axes_top()
+        ax2 = self._view_caches["2d"].ax
+        ax3 = self._view_caches["3d"].ax
+        if ax2 is not None:
+            bottom_2d = base - float(_INTERACTIVE_2D_BOTTOM_EXTRA)
+            pos = ax2.get_position()
+            height = max(top - bottom_2d, 0.08)
+            ax2.set_position([pos.x0, bottom_2d, pos.width, height])
+        if ax3 is not None:
+            bottom_3d = base + float(_INTERACTIVE_3D_BOTTOM_LIFT)
+            pos = ax3.get_position()
+            height = max(top - bottom_3d, 0.08)
+            ax3.set_position([pos.x0, bottom_3d, pos.width, height])
+
     def _build_controls(self) -> None:
         assert self.figure is not None
         labels = list(_BASE_TOGGLE_LABELS)
@@ -355,8 +433,23 @@ def _build_controls(self) -> None:
             labels.extend(_SCHEME_TOGGLE_LABELS)
         if has_tensor_inspector:
             labels.append(_TENSOR_INSPECTOR_LABEL)
+        cb_bounds = _interactive_checkbox_bounds(
+            include_scheme_toggles=has_scheme_toggles,
+            include_tensor_inspector=has_tensor_inspector,
+        )
+        cb_bottom = float(cb_bounds[1])
+        check_ax = self.figure.add_axes(cb_bounds)
+        _style_interactive_control_axes(check_ax)
+        self._check_ax = check_ax
         if not self._external_ax:
-            radio_ax = self.figure.add_axes(_VIEW_SELECTOR_BOUNDS)
+            radio_bounds: tuple[float, float, float, float] = (
+                _VIEW_SELECTOR_LEFT,
+                cb_bottom,
+                _VIEW_SELECTOR_WIDTH,
+                _VIEW_SELECTOR_HEIGHT,
+            )
+            radio_ax = self.figure.add_axes(radio_bounds)
+            _style_interactive_control_axes(radio_ax)
             self._radio_ax = radio_ax
             active_index = 0 if self.current_view == "2d" else 1
             self._radio = RadioButtons(
@@ -367,13 +460,6 @@ def _build_controls(self) -> None:
                 radio_props=_INTERACTIVE_RADIO_PROPS,
             )
             self._radio.on_clicked(self._on_view_clicked)
-        check_ax = self.figure.add_axes(
-            _interactive_checkbox_bounds(
-                include_scheme_toggles=has_scheme_toggles,
-                include_tensor_inspector=has_tensor_inspector,
-            )
-        )
-        self._check_ax = check_ax
         statuses = [
             self.hover_on,
             self.tensor_labels_on,
@@ -489,6 +575,8 @@ def _apply_scene_state(self, scene: _InteractiveSceneState) -> None:
             self._tensor_inspector.set_enabled(self.tensor_inspector_on)
         _apply_scene_hover_state(scene, hover_on=self.hover_on)
         self._sync_checkbuttons()
+        if not self._external_ax:
+            self._apply_interactive_figure_layout()
         scene.ax.figure.canvas.draw_idle()
 
     def set_view(self, view: ViewName) -> None:

tests/test_engineering_baseline.py

@@ -153,7 +153,7 @@ def test_compute_axis_directions_dense_dangling_chain_completes_quickly() -> Non
 def test_pyproject_declares_smoke_and_perf_markers() -> None:
     content = Path("pyproject.toml").read_text(encoding="utf-8")
 
-    assert 'markers = [' in content
+    assert "markers = [" in content
     assert '"perf: runtime-sensitive regression checks and throughput guards"' in content
     assert '"smoke: lightweight render smoke checks"' in content
 

tests/test_plotting.py

@@ -626,9 +626,9 @@ def test_show_tensor_network_places_view_selector_between_options_and_playback_s
 
     assert check_bounds[2] <= 0.21
     assert radio_bounds[0] >= check_right - 0.02
-    assert radio_bounds[2] <= 0.06
+    assert radio_bounds[2] <= 0.09
     assert slider_bounds[0] >= radio_right - 0.02
-    assert 0.02 <= radio_bounds[1] <= 0.06
+    assert abs(radio_bounds[1] - check_bounds[1]) < 0.02
     assert play_bounds[0] > slider_right