tensor-network-visualization 1.6.1__tar.gz → 1.6.3__tar.gz

{tensor_network_visualization-1.6.1/src/tensor_network_visualization.egg-info → tensor_network_visualization-1.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensor-network-visualization
-Version: 1.6.1
+Version: 1.6.3
 Summary: Minimal Matplotlib visualizations for TensorKrowch, TensorNetwork, Quimb, TeNPy, and traced PyTorch/NumPy einsum tensor networks.
 Author: Alejandro Mata Ali
 License-Expression: MIT
@@ -156,10 +156,27 @@ fig.savefig("tensorkrowch-network.png", bbox_inches="tight")
 Use `show=False` when you want to save or customize the figure yourself. Use
 `show_controls=False` when you want a clean static figure with no embedded Matplotlib controls.
 
-In Jupyter, install `"tensor-network-visualization[jupyter]"`, run `%matplotlib widget` before
-plotting, then call `show_tensor_network` as usual (default `show_controls=True`) for interactive
-figures with embedded controls. See [Installation](docs/installation.md) and
-[User Guide](docs/guide.md) for details.
+In a notebook, use this exact recipe:
+
+```python
+%pip install "tensor-network-visualization[jupyter]"
+```
+
+If you just installed that extra in the current kernel, restart the kernel once. Then, in the
+first plotting cell:
+
+```python
+%matplotlib widget
+
+from tensor_network_viz import PlotConfig, show_tensor_network
+
+fig, ax = show_tensor_network(
+    network,
+    config=PlotConfig(show_tensor_labels=True, hover_labels=True),
+)
+```
+
+See [Installation](docs/installation.md) and [User Guide](docs/guide.md) for details.
 
 ## Documentation
 

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/README.md

@@ -105,10 +105,27 @@ fig.savefig("tensorkrowch-network.png", bbox_inches="tight")
 Use `show=False` when you want to save or customize the figure yourself. Use
 `show_controls=False` when you want a clean static figure with no embedded Matplotlib controls.
 
-In Jupyter, install `"tensor-network-visualization[jupyter]"`, run `%matplotlib widget` before
-plotting, then call `show_tensor_network` as usual (default `show_controls=True`) for interactive
-figures with embedded controls. See [Installation](docs/installation.md) and
-[User Guide](docs/guide.md) for details.
+In a notebook, use this exact recipe:
+
+```python
+%pip install "tensor-network-visualization[jupyter]"
+```
+
+If you just installed that extra in the current kernel, restart the kernel once. Then, in the
+first plotting cell:
+
+```python
+%matplotlib widget
+
+from tensor_network_viz import PlotConfig, show_tensor_network
+
+fig, ax = show_tensor_network(
+    network,
+    config=PlotConfig(show_tensor_labels=True, hover_labels=True),
+)
+```
+
+See [Installation](docs/installation.md) and [User Guide](docs/guide.md) for details.
 
 ## Documentation
 

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "tensor-network-visualization"
-version = "1.6.1"
+version = "1.6.3"
 description = "Minimal Matplotlib visualizations for TensorKrowch, TensorNetwork, Quimb, TeNPy, and traced PyTorch/NumPy einsum tensor networks."
 authors = [{ name = "Alejandro Mata Ali" }]
 readme = "README.md"

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3/src/tensor_network_visualization.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tensor-network-visualization
-Version: 1.6.1
+Version: 1.6.3
 Summary: Minimal Matplotlib visualizations for TensorKrowch, TensorNetwork, Quimb, TeNPy, and traced PyTorch/NumPy einsum tensor networks.
 Author: Alejandro Mata Ali
 License-Expression: MIT
@@ -156,10 +156,27 @@ fig.savefig("tensorkrowch-network.png", bbox_inches="tight")
 Use `show=False` when you want to save or customize the figure yourself. Use
 `show_controls=False` when you want a clean static figure with no embedded Matplotlib controls.
 
-In Jupyter, install `"tensor-network-visualization[jupyter]"`, run `%matplotlib widget` before
-plotting, then call `show_tensor_network` as usual (default `show_controls=True`) for interactive
-figures with embedded controls. See [Installation](docs/installation.md) and
-[User Guide](docs/guide.md) for details.
+In a notebook, use this exact recipe:
+
+```python
+%pip install "tensor-network-visualization[jupyter]"
+```
+
+If you just installed that extra in the current kernel, restart the kernel once. Then, in the
+first plotting cell:
+
+```python
+%matplotlib widget
+
+from tensor_network_viz import PlotConfig, show_tensor_network
+
+fig, ax = show_tensor_network(
+    network,
+    config=PlotConfig(show_tensor_labels=True, hover_labels=True),
+)
+```
+
+See [Installation](docs/installation.md) and [User Guide](docs/guide.md) for details.
 
 ## Documentation
 

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/src/tensor_network_visualization.egg-info/SOURCES.txt

@@ -7,9 +7,11 @@ src/tensor_network_visualization.egg-info/dependency_links.txt
 src/tensor_network_visualization.egg-info/requires.txt
 src/tensor_network_visualization.egg-info/top_level.txt
 src/tensor_network_viz/__init__.py
+src/tensor_network_viz/_auto_display.py
 src/tensor_network_viz/_contraction_viewer_style.py
 src/tensor_network_viz/_contraction_viewer_ui.py
 src/tensor_network_viz/_engine_specs.py
+src/tensor_network_viz/_import_state.py
 src/tensor_network_viz/_input_inspection.py
 src/tensor_network_viz/_interactive_scene.py
 src/tensor_network_viz/_logging.py
@@ -18,6 +20,8 @@ src/tensor_network_viz/_registry.py
 src/tensor_network_viz/_tensor_comparison_support.py
 src/tensor_network_viz/_tensor_elements_controller.py
 src/tensor_network_viz/_tensor_elements_data.py
+src/tensor_network_viz/_tensor_elements_inputs.py
+src/tensor_network_viz/_tensor_elements_models.py
 src/tensor_network_viz/_tensor_elements_payloads.py
 src/tensor_network_viz/_tensor_elements_rendering.py
 src/tensor_network_viz/_tensor_elements_support.py
@@ -47,6 +51,8 @@ src/tensor_network_viz/_core/graph.py
 src/tensor_network_viz/_core/graph_cache.py
 src/tensor_network_viz/_core/graph_utils.py
 src/tensor_network_viz/_core/layout_structure.py
+src/tensor_network_viz/_core/layout_structure_coordinates.py
+src/tensor_network_viz/_core/layout_structure_sparse_grid.py
 src/tensor_network_viz/_core/renderer.py
 src/tensor_network_viz/_core/draw/__init__.py
 src/tensor_network_viz/_core/draw/constants.py
@@ -64,6 +70,9 @@ src/tensor_network_viz/_core/draw/label_descriptors.py
 src/tensor_network_viz/_core/draw/labels_misc.py
 src/tensor_network_viz/_core/draw/pick_distance.py
 src/tensor_network_viz/_core/draw/plotter.py
+src/tensor_network_viz/_core/draw/plotter_2d.py
+src/tensor_network_viz/_core/draw/plotter_3d.py
+src/tensor_network_viz/_core/draw/plotter_common.py
 src/tensor_network_viz/_core/draw/render_prep.py
 src/tensor_network_viz/_core/draw/scene_state.py
 src/tensor_network_viz/_core/draw/tensors.py
@@ -111,6 +120,7 @@ src/tensor_network_viz/tensorkrowch/renderer.py
 src/tensor_network_viz/tensornetwork/__init__.py
 src/tensor_network_viz/tensornetwork/graph.py
 src/tensor_network_viz/tensornetwork/renderer.py
+tests/test_bench_user_workflows.py
 tests/test_ci_workflow.py
 tests/test_contraction_cost.py
 tests/test_contraction_groups_once.py

tensor_network_visualization-1.6.3/src/tensor_network_viz/_auto_display.py

@@ -0,0 +1,54 @@
+"""Shared helpers for auto-resolving display toggles."""
+
+from __future__ import annotations
+
+from dataclasses import replace
+
+from ._core.graph import _GraphData
+from .config import PlotConfig
+
+AUTO_VISIBLE_TENSOR_THRESHOLD: int = 25
+
+
+def count_visible_tensors(graph: _GraphData) -> int:
+    """Count visible non-virtual tensors, falling back to total nodes when needed."""
+    visible_tensors = sum(1 for node in graph.nodes.values() if not node.is_virtual)
+    return visible_tensors or len(graph.nodes)
+
+
+def resolve_auto_display_flag(
+    value: bool | None,
+    *,
+    visible_tensor_count: int,
+) -> bool:
+    """Resolve one optional display flag using the shared visibility heuristic."""
+    if value is not None:
+        return bool(value)
+    return int(visible_tensor_count) < AUTO_VISIBLE_TENSOR_THRESHOLD
+
+
+def resolve_auto_display_config(
+    config: PlotConfig,
+    *,
+    visible_tensor_count: int,
+) -> PlotConfig:
+    """Freeze auto display flags into concrete booleans for the current render."""
+    return replace(
+        config,
+        show_nodes=resolve_auto_display_flag(
+            config.show_nodes,
+            visible_tensor_count=visible_tensor_count,
+        ),
+        show_tensor_labels=resolve_auto_display_flag(
+            config.show_tensor_labels,
+            visible_tensor_count=visible_tensor_count,
+        ),
+    )
+
+
+__all__ = [
+    "AUTO_VISIBLE_TENSOR_THRESHOLD",
+    "count_visible_tensors",
+    "resolve_auto_display_config",
+    "resolve_auto_display_flag",
+]

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/src/tensor_network_viz/_core/draw/dangling_self_edges.py

@@ -169,6 +169,7 @@ def _draw_dangling_edge_labels(
         dimensions=dimensions,
         is_physical=True,
         preferred_fontsize_pt=config.edge_label_fontsize,
+        fast_text_metrics=bool(p.fast_text_metrics),
     )
     text_kwargs = _edge_index_text_kwargs(
         config,
@@ -392,6 +393,7 @@ def _draw_self_loop_edge_labels(
             is_physical=False,
             peer_captions_for_width=peer_width,
             preferred_fontsize_pt=config.edge_label_fontsize,
+            fast_text_metrics=bool(p.fast_text_metrics),
         )
         text_kwargs_a = {
             **_edge_index_text_kwargs(
@@ -446,6 +448,7 @@ def _draw_self_loop_edge_labels(
             is_physical=False,
             peer_captions_for_width=peer_width,
             preferred_fontsize_pt=config.edge_label_fontsize,
+            fast_text_metrics=bool(p.fast_text_metrics),
         )
         text_kwargs_b = {
             **_edge_index_text_kwargs(

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/src/tensor_network_viz/_core/draw/edge_labels.py

@@ -91,6 +91,7 @@ def _plot_contraction_index_captions(
             is_physical=False,
             peer_captions_for_width=peer_for_width,
             preferred_fontsize_pt=config.edge_label_fontsize,
+            fast_text_metrics=bool(p.fast_text_metrics),
         )
         text_kwargs = _edge_index_text_kwargs(
             config,

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/src/tensor_network_viz/_core/draw/fonts_and_scale.py

@@ -28,6 +28,7 @@ def _figure_size_sqrt_ratio(fig: Figure) -> float:
 
 
 _TEXTPATH_WIDTH_CACHE_MAX: int = 8192
+_FAST_TEXT_METRICS_LABEL_THRESHOLD: int = 256
 
 
 @functools.lru_cache(maxsize=_TEXTPATH_WIDTH_CACHE_MAX)
@@ -40,8 +41,38 @@ def _textpath_width_pts_cached(text: str, fontsize_pt_key: float) -> float:
     return float(tp.get_extents().width)
 
 
-def _textpath_width_pts(text: str, *, fontsize_pt: float) -> float:
+@functools.lru_cache(maxsize=_TEXTPATH_WIDTH_CACHE_MAX)
+def _textpath_width_pts_fast_cached(text: str, fontsize_pt_key: float) -> float:
+    """Fast TextPath width approximation from raw vertices.
+
+    ``TextPath.get_extents()`` walks Bezier extrema and becomes expensive for many unique labels.
+    The vertex span is slightly less exact, but avoids that path for dense interactive views.
+    """
+    if not text.strip():
+        return 0.0
+    fp = FontProperties(size=float(fontsize_pt_key))
+    tp = TextPath((0.0, 0.0), text, prop=fp)
+    vertices = np.asarray(tp.vertices, dtype=float)
+    if vertices.size == 0:
+        return 0.0
+    return float(vertices[:, 0].max() - vertices[:, 0].min())
+
+
+def _textpath_width_pts_fast(text: str, *, fontsize_pt: float) -> float:
+    """Fast horizontal span of *text* at *fontsize_pt* for dense label views."""
+    key = round(float(fontsize_pt), 6)
+    return float(_textpath_width_pts_fast_cached(text, key))
+
+
+def _textpath_width_pts(
+    text: str,
+    *,
+    fontsize_pt: float,
+    fast_metrics: bool = False,
+) -> float:
     """Horizontal advance of *text* from Matplotlib TextPath at *fontsize_pt* (points)."""
+    if fast_metrics:
+        return _textpath_width_pts_fast(text, fontsize_pt=fontsize_pt)
     key = round(float(fontsize_pt), 6)
     return float(_textpath_width_pts_cached(text, key))
 
@@ -86,6 +117,7 @@ class _DrawScaleParams:
     label_offset: float
     ellipse_w: float
     ellipse_h: float
+    fast_text_metrics: bool = False
 
 
 def _draw_scale_params(
@@ -96,11 +128,18 @@ def _draw_scale_params(
     is_3d: bool,
     font_figure_scale: float = 1.0,
     label_slots: int = 1,
+    fast_text_metrics: bool | None = None,
 ) -> _DrawScaleParams:
     """Compute scale-dependent drawing parameters from config."""
     fs = font_figure_scale
     tensor_fs = _figure_base_size_scale(fig)
-    bbox_pad = _index_label_bbox_pad(max(1, label_slots))
+    resolved_label_slots = max(1, int(label_slots))
+    bbox_pad = _index_label_bbox_pad(resolved_label_slots)
+    use_fast_text_metrics = (
+        resolved_label_slots >= _FAST_TEXT_METRICS_LABEL_THRESHOLD
+        if fast_text_metrics is None
+        else bool(fast_text_metrics)
+    )
     r = (
         config.node_radius if config.node_radius is not None else PlotConfig.DEFAULT_NODE_RADIUS
     ) * scale
@@ -128,6 +167,7 @@ def _draw_scale_params(
         label_offset=0.08 * scale * float(np.clip(0.82 + 0.22 * fs, 0.75, 1.2)),
         ellipse_w=0.16 * scale,
         ellipse_h=0.12 * scale,
+        fast_text_metrics=use_fast_text_metrics,
     )
 
 
@@ -176,9 +216,12 @@ __all__ = [
     "_figure_base_size_scale",
     "_figure_relative_font_scale",
     "_figure_size_sqrt_ratio",
+    "_FAST_TEXT_METRICS_LABEL_THRESHOLD",
     "_index_label_bbox_pad",
     "_on_2d_limits_changed",
     "_register_2d_zoom_font_scaling",
     "_textpath_width_pts",
     "_textpath_width_pts_cached",
+    "_textpath_width_pts_fast",
+    "_textpath_width_pts_fast_cached",
 ]

{tensor_network_visualization-1.6.1 → tensor_network_visualization-1.6.3}/src/tensor_network_viz/_core/draw/graph_pipeline.py

@@ -16,6 +16,7 @@ from .render_prep import (
 
 if TYPE_CHECKING:
     from ..._interaction.scheme import _ContractionSchemeBundle
+    from .scene_state import _FocusSceneFeedback
 
 
 def _refresh_contraction_hover(
@@ -159,6 +160,7 @@ def _draw_graph(
     contraction_controls_build_ui: bool = True,
     register_contraction_controls_on_figure: bool = True,
     build_scene_state: bool = True,
+    focus_feedback: _FocusSceneFeedback | None = None,
 ) -> None:
     context = _prepare_render_context(
         ax=ax,
@@ -244,6 +246,7 @@ def _draw_graph(
             scale=scale,
             hover_state=hover_state,
             tensor_disk_radius_px_3d=tensor_disk_radius_px_3d,
+            focus_feedback=focus_feedback,
         )
         scene.contraction_controls = controls
         set_scene(ax, scene)

tensor_network_visualization-1.6.3/src/tensor_network_viz/_core/draw/plotter.py

@@ -0,0 +1,68 @@
+from __future__ import annotations
+
+from typing import Any, Literal, Protocol, cast
+
+import numpy as np
+
+from ...config import PlotConfig
+from .fonts_and_scale import _DrawScaleParams
+from .plotter_2d import _make_2d_plotter
+from .plotter_3d import _make_3d_plotter
+from .plotter_common import (
+    NodeRenderMode,
+    _edge_outline_effects,
+    _graph_edge_degree,
+    _node_edge_degrees,
+    _NodeArtistBundle,
+    _visible_degree_one_mask,
+)
+
+
+class _PlotAdapter(Protocol):
+    """Protocol for dimension-aware plotting (2D vs 3D)."""
+
+    def plot_line(self, start: np.ndarray, end: np.ndarray, **kwargs: Any) -> None: ...
+    def plot_curve(self, curve: np.ndarray, **kwargs: Any) -> None: ...
+    def plot_text(self, pos: np.ndarray, text: str, **kwargs: Any) -> None: ...
+    def draw_tensor_nodes(
+        self,
+        coords: np.ndarray,
+        *,
+        config: PlotConfig,
+        p: _DrawScaleParams,
+        degree_one_mask: np.ndarray,
+        mode: NodeRenderMode,
+    ) -> None: ...
+    def draw_virtual_hub_markers(
+        self,
+        coords: np.ndarray,
+        *,
+        config: PlotConfig,
+        zorder: float,
+    ) -> None: ...
+    def get_node_artist_bundle(self) -> _NodeArtistBundle | None: ...
+    def get_edge_artists(self) -> tuple[Any, ...]: ...
+    def style_axes(self, coords: np.ndarray, *, view_margin: float) -> None: ...
+
+
+def _make_plotter(
+    ax: Any,
+    *,
+    dimensions: Literal[2, 3],
+    hover_edge_targets: list[tuple[np.ndarray, str]] | None = None,
+) -> _PlotAdapter:
+    """Create a dimension-aware plot adapter."""
+    if dimensions == 2:
+        return cast(_PlotAdapter, _make_2d_plotter(ax, hover_edge_targets=hover_edge_targets))
+    return cast(_PlotAdapter, _make_3d_plotter(ax, hover_edge_targets=hover_edge_targets))
+
+
+__all__ = [
+    "_PlotAdapter",
+    "_NodeArtistBundle",
+    "_edge_outline_effects",
+    "_graph_edge_degree",
+    "_make_plotter",
+    "_node_edge_degrees",
+    "_visible_degree_one_mask",
+]

tensor_network_visualization-1.6.3/src/tensor_network_viz/_core/draw/plotter_2d.py

@@ -0,0 +1,229 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+import numpy as np
+from matplotlib.artist import Artist
+from matplotlib.axes import Axes
+from matplotlib.collections import LineCollection, PatchCollection, PathCollection
+from matplotlib.patches import Circle
+
+from ...config import PlotConfig
+from .constants import _EDGE_LINE_CAP_STYLE, _EDGE_LINE_JOIN_STYLE, _ZORDER_NODE_DISK
+from .fonts_and_scale import _DrawScaleParams
+from .plotter_common import (
+    _COMPACT_NODE_MARKER_AREA_2D_PT2,
+    _COMPACT_NODE_MARKER_LINEWIDTH_PT,
+    _VIRTUAL_HUB_MARKER_AREA_2D_PT2,
+    _VIRTUAL_HUB_MARKER_LINEWIDTH_PT,
+    NodeRenderMode,
+    _edge_outline_effects,
+    _NodeArtistBundle,
+)
+from .viewport_geometry import (
+    _apply_axis_limits_with_outset,
+    _apply_edge_line_style,
+    _apply_text_no_clip,
+)
+
+
+def _make_2d_plotter(
+    ax: Axes,
+    *,
+    hover_edge_targets: list[tuple[np.ndarray, str]] | None = None,
+) -> object:
+    class _2DPlotter:
+        __slots__ = (
+            "_ax",
+            "_edge_segments",
+            "_hover_edge_targets",
+            "_edge_artists",
+            "_node_disk_collection",
+            "_node_disk_collections",
+            "_node_artist_bundle",
+        )
+
+        def __init__(
+            self,
+            ax_2d: Axes,
+            hover_edges: list[tuple[np.ndarray, str]] | None,
+        ) -> None:
+            self._ax = ax_2d
+            self._edge_segments: list[tuple[float, str, float, np.ndarray]] = []
+            self._hover_edge_targets = hover_edges
+            self._edge_artists: list[Artist] = []
+            self._node_disk_collection: PatchCollection | PathCollection | None = None
+            self._node_disk_collections: list[PatchCollection | PathCollection] = []
+            self._node_artist_bundle: _NodeArtistBundle | None = None
+
+        def clear_node_disk_collections(self) -> None:
+            self._node_disk_collections.clear()
+            self._node_disk_collection = None
+            self._node_artist_bundle = None
+
+        def get_node_artist_bundle(self) -> _NodeArtistBundle | None:
+            return self._node_artist_bundle
+
+        def get_edge_artists(self) -> tuple[Artist, ...]:
+            return tuple(self._edge_artists)
+
+        def flush_edge_collections(self) -> None:
+            """Batch buffered edges into a few LineCollections (call after all edges drawn)."""
+            if not self._edge_segments:
+                return
+            groups: dict[tuple[float, str, float], list[np.ndarray]] = defaultdict(list)
+            for z, color, lw, seg in self._edge_segments:
+                groups[(z, color, lw)].append(seg)
+            ax_ = self._ax
+            for (z, color, lw), segs in sorted(groups.items(), key=lambda kv: kv[0][0]):
+                coll = LineCollection(
+                    segs,
+                    colors=color,
+                    linewidths=lw,
+                    zorder=z,
+                    capstyle=_EDGE_LINE_CAP_STYLE,
+                    joinstyle=_EDGE_LINE_JOIN_STYLE,
+                )
+                coll.set_path_effects(_edge_outline_effects(float(lw)))
+                ax_.add_collection(coll, autolim=False)
+                self._edge_artists.append(coll)
+            self._edge_segments.clear()
+
+        def plot_line(self, start: np.ndarray, end: np.ndarray, **kwargs: Any) -> None:
+            _apply_edge_line_style(kwargs)
+            z = float(kwargs.get("zorder", 1))
+            color = str(kwargs.get("color", "#000000"))
+            lw = float(kwargs.get("linewidth", 1.0))
+            seg = np.array(
+                [[float(start[0]), float(start[1])], [float(end[0]), float(end[1])]],
+                dtype=float,
+            )
+            self._edge_segments.append((z, color, lw, seg))
+
+        def plot_curve(self, curve: np.ndarray, **kwargs: Any) -> None:
+            _apply_edge_line_style(kwargs)
+            z = float(kwargs.get("zorder", 1))
+            color = str(kwargs.get("color", "#000000"))
+            lw = float(kwargs.get("linewidth", 1.0))
+            seg = np.asarray(curve[:, :2], dtype=float, order="C")
+            self._edge_segments.append((z, color, lw, seg))
+
+        def plot_text(self, pos: np.ndarray, text: str, **kwargs: Any) -> None:
+            _apply_text_no_clip(kwargs)
+            self._ax.text(pos[0], pos[1], text, **kwargs)
+
+        def draw_tensor_node(
+            self,
+            coord: np.ndarray,
+            *,
+            config: PlotConfig,
+            p: _DrawScaleParams,
+            degree_one: bool,
+            mode: NodeRenderMode,
+            zorder: float,
+        ) -> None:
+            fc = config.node_color_degree_one if degree_one else config.node_color
+            ec = config.node_edge_color_degree_one if degree_one else config.node_edge_color
+            if mode == "compact":
+                coll = self._ax.scatter(
+                    [float(coord[0])],
+                    [float(coord[1])],
+                    s=_COMPACT_NODE_MARKER_AREA_2D_PT2,
+                    c=[fc],
+                    edgecolors=[ec],
+                    linewidths=_COMPACT_NODE_MARKER_LINEWIDTH_PT,
+                    zorder=zorder,
+                )
+            else:
+                patch = Circle((float(coord[0]), float(coord[1])), radius=p.r)
+                coll = PatchCollection(
+                    [patch],
+                    facecolors=[fc],
+                    edgecolors=[ec],
+                    linewidths=float(p.lw),
+                    zorder=zorder,
+                    match_original=False,
+                )
+                self._ax.add_collection(coll, autolim=False)
+            self._node_disk_collections.append(coll)
+            self._node_artist_bundle = _NodeArtistBundle(
+                mode=mode,
+                artists=tuple(self._node_disk_collections),
+                hover_target=tuple(self._node_disk_collections),
+            )
+
+        def draw_tensor_nodes(
+            self,
+            coords: np.ndarray,
+            *,
+            config: PlotConfig,
+            p: _DrawScaleParams,
+            degree_one_mask: np.ndarray,
+            mode: NodeRenderMode,
+        ) -> None:
+            n = int(coords.shape[0])
+            if n == 0:
+                return
+            faces = [
+                config.node_color_degree_one if degree_one_mask[i] else config.node_color
+                for i in range(n)
+            ]
+            c1 = config.node_edge_color_degree_one
+            c0 = config.node_edge_color
+            edges_ = [c1 if degree_one_mask[i] else c0 for i in range(n)]
+            if mode == "compact":
+                coll = self._ax.scatter(
+                    coords[:, 0],
+                    coords[:, 1],
+                    s=_COMPACT_NODE_MARKER_AREA_2D_PT2,
+                    c=faces,
+                    edgecolors=edges_,
+                    linewidths=_COMPACT_NODE_MARKER_LINEWIDTH_PT,
+                    zorder=_ZORDER_NODE_DISK,
+                )
+            else:
+                patches = [
+                    Circle((float(coords[i, 0]), float(coords[i, 1])), radius=p.r) for i in range(n)
+                ]
+                coll = PatchCollection(
+                    patches,
+                    facecolors=faces,
+                    edgecolors=edges_,
+                    linewidths=float(p.lw),
+                    zorder=_ZORDER_NODE_DISK,
+                    match_original=False,
+                )
+                self._ax.add_collection(coll, autolim=False)
+            self._node_disk_collection = coll
+            self._node_disk_collections = [coll]
+            self._node_artist_bundle = _NodeArtistBundle(
+                mode=mode,
+                artists=(coll,),
+                hover_target=coll,
+            )
+
+        def draw_virtual_hub_markers(
+            self,
+            coords: np.ndarray,
+            *,
+            config: PlotConfig,
+            zorder: float,
+        ) -> None:
+            if int(coords.shape[0]) == 0:
+                return
+            self._ax.scatter(
+                coords[:, 0],
+                coords[:, 1],
+                marker="^",
+                s=_VIRTUAL_HUB_MARKER_AREA_2D_PT2,
+                c=[config.dangling_edge_color],
+                edgecolors=[config.node_edge_color_degree_one],
+                linewidths=_VIRTUAL_HUB_MARKER_LINEWIDTH_PT,
+                zorder=zorder,
+            )
+
+        def style_axes(self, coords: np.ndarray, *, view_margin: float) -> None:
+            _apply_axis_limits_with_outset(self._ax, coords, view_margin=view_margin, dimensions=2)
+
+    return _2DPlotter(ax, hover_edge_targets)