nodebpy 520.18.0__tar.gz → 520.19.0__tar.gz

{nodebpy-520.18.0 → nodebpy-520.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.18.0
+Version: 520.19.0
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
@@ -8,10 +8,12 @@ License: GPL-3.0-or-later
 Requires-Dist: bpy==5.2.* ; extra == 'bpy'
 Requires-Dist: ruff>=0.14.11 ; extra == 'format'
 Requires-Dist: networkx>=3.6.1 ; extra == 'networkx'
+Requires-Dist: matplotlib>=3.8 ; extra == 'plot'
 Requires-Python: >=3.13
 Provides-Extra: bpy
 Provides-Extra: format
 Provides-Extra: networkx
+Provides-Extra: plot
 Description-Content-Type: text/markdown
 
 # nodebpy

{nodebpy-520.18.0 → nodebpy-520.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.18.0"
+version = "520.19.0"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
@@ -16,6 +16,9 @@ nodebpy = "nodebpy:main"
 networkx = [
     "networkx>=3.6.1",
 ]
+plot = [
+    "matplotlib>=3.8",
+]
 bpy = [
     "bpy==5.2.*",
 ]
@@ -46,6 +49,7 @@ dev = [
     "griffe<2.0.0",
     "ty==0.0.74",
     "types-networkx>=3.6.1.20260728",
+    "matplotlib>=3.11.2",
 ]
 
 # The bpy stubs mark most collections/pointers as `| None` and cannot type
@@ -67,3 +71,4 @@ ignore = ["SIM117", "RUF059"]
 [tool.ruff.lint.per-file-ignores]
 "tests/test_codegen.py" = ["S102"]
 "tests/test_assets.py" = ["S102"]
+"tests/test_layout_snapshot.py" = ["S102"]

nodebpy-520.19.0/src/nodebpy/__init__.py

@@ -0,0 +1,26 @@
+from . import builder, export, nodes, types
+from .builder import (
+    ArrangeMethod,
+    SimpleOptions,
+    SugiyamaOptions,
+    TreeBuilder,
+    arrange,
+    default_sugiyama_options,
+)
+from .nodes import compositor, geometry, shader
+
+__all__ = [
+    "ArrangeMethod",
+    "SimpleOptions",
+    "SugiyamaOptions",
+    "TreeBuilder",
+    "arrange",
+    "builder",
+    "compositor",
+    "default_sugiyama_options",
+    "export",
+    "geometry",
+    "nodes",
+    "shader",
+    "types",
+]

{nodebpy-520.18.0 → nodebpy-520.19.0}/src/nodebpy/assets/__init__.py

@@ -10,12 +10,14 @@ compositor}.assets`` and are re-exported alongside the built-in nodes.
 ``dump_library`` and ``build_library`` round-trip a ``.blend`` asset library
 through Python source: every asset is dumped to its own ``.py`` file (the
 version-controlled source of truth) and the ``.blend`` is rebuilt from them
-(``python -m nodebpy.assets dump/build``).
+(``python -m nodebpy.assets dump/build``). ``plot_library`` renders node
+groups from a ``.blend`` to PNG images by name or wildcard
+(``python -m nodebpy.assets plot``), for review outside Blender.
 """
 
 from ..builder import AssetLibrary, BundledLibrary, PackageLibrary
 from ._codegen import generate_asset_api, generate_asset_modules
-from ._library import build_library, dump_library
+from ._library import build_library, dump_library, plot_library
 
 __all__ = [
     "AssetLibrary",
@@ -25,4 +27,5 @@ __all__ = [
     "dump_library",
     "generate_asset_api",
     "generate_asset_modules",
+    "plot_library",
 ]

{nodebpy-520.18.0 → nodebpy-520.19.0}/src/nodebpy/assets/__main__.py

@@ -77,9 +77,12 @@ def parse_args() -> argparse.Namespace:  # pragma: no cover - CLI wrapper
             ".blend to per-asset .py source files\n"
             "  build <source-dir> <blend>   rebuild the .blend asset library "
             "from dumped .py source files\n"
+            "  plot <blend> <output-dir> [names ...]\n"
+            "                               render node groups (wildcards "
+            "supported) to PNG images\n"
             "\n"
-            "See 'python -m nodebpy.assets dump --help' and "
-            "'python -m nodebpy.assets build --help' for their options."
+            "See 'python -m nodebpy.assets dump --help', '… build --help' "
+            "and '… plot --help' for their options."
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
@@ -124,9 +127,10 @@ def parse_args() -> argparse.Namespace:  # pragma: no cover - CLI wrapper
 
 
 def main() -> None:  # pragma: no cover - CLI wrapper
-    # The dump/build subcommands (blend ↔ .py round-trip) have their own
-    # parser; everything else keeps the original flag-based interface.
-    if len(sys.argv) > 1 and sys.argv[1] in ("dump", "build"):
+    # The dump/build/plot subcommands (blend ↔ .py round-trip, PNG renders)
+    # have their own parser; everything else keeps the original flag-based
+    # interface.
+    if len(sys.argv) > 1 and sys.argv[1] in ("dump", "build", "plot"):
         from ._library import main as library_main
 
         library_main(sys.argv[1:])

{nodebpy-520.18.0 → nodebpy-520.19.0}/src/nodebpy/assets/_library.py

@@ -56,6 +56,7 @@ rebuilding reuses same-named trees (which would bake a stale group into the
 
 from __future__ import annotations
 
+import fnmatch
 import importlib
 import importlib.machinery
 import importlib.util
@@ -64,11 +65,20 @@ import re
 import shutil
 import sys
 import uuid
+from collections.abc import Iterable
+from contextlib import nullcontext
+from dataclasses import replace
 from pathlib import Path
 
 import bpy
 
-from ..builder import NodeGroupBuilder, TreeBuilder, build_from_source
+from ..builder import (
+    NodeGroupBuilder,
+    SugiyamaOptions,
+    TreeBuilder,
+    build_from_source,
+    default_sugiyama_options,
+)
 from ..builder._utils import normalize_name
 from ..export.codegen import (
     _ID_COLLECTIONS,
@@ -968,6 +978,8 @@ def build_library(
     allow_existing: bool = False,
     resources: str | Path | None = None,
     on_missing: str = "error",
+    add_reroutes: bool = False,
+    arrange: SugiyamaOptions | None = None,
 ) -> list[str]:
     """Rebuild a ``.blend`` asset library from sources written by
     :func:`dump_library`.
@@ -991,6 +1003,17 @@ def build_library(
     socket defaults empty. The default ``on_missing="error"`` raises upfront,
     listing everything missing.
 
+    ``arrange`` tunes how the built trees are laid out: a
+    :class:`~nodebpy.SugiyamaOptions` with any of its settings (spacing,
+    crossing-reduction iterations, direction, socket alignment, ...) is
+    scoped over the build via
+    :func:`nodebpy.builder.default_sugiyama_options`. ``add_reroutes=True``
+    additionally inserts reroute nodes to route long links around nodes
+    (the node-arrange addon's behaviour); it composes with ``arrange``.
+    Either only affects modules that leave the arrangement at its default —
+    sources dumped with ``snapshot_positions`` disable arrangement and keep
+    their authored layout.
+
     The built trees stay in the current session afterwards. Because
     ``create_group()`` reuses an existing tree of the same name (that is what
     deduplicates groups shared between asset files), the session must not
@@ -1077,61 +1100,75 @@ def build_library(
         on_missing,
     )
 
-    # Materials first: asset trees look them up by name while building.
-    built_materials = []
-    for file, module in material_modules:
-        material_cls = module.MATERIAL  # ty: ignore[unresolved-attribute]
-        if not (
-            isinstance(material_cls, type)
-            and issubclass(material_cls, NodeGroupBuilder)
-        ):
-            raise TypeError(f"{file}: MATERIAL is not a node-group class")
-        name = getattr(module, "MATERIAL_NAME", None) or material_cls._name
-        # The material recipe may instantiate typed-API asset classes, which
-        # must build from their _build_group source, not append.
-        with build_from_source():
-            material = _build_material(material_cls, name)
-        for key, value in getattr(module, "MATERIAL_PROPERTIES", {}).items():
-            try:
-                setattr(material, key, value)
-            except AttributeError:
-                print(f"  {name}: skipping read-only material property {key!r}")
-        built_materials.append(material)
-
-    trees = []
-    for file, module in asset_modules:
-        asset_cls = module.ASSET  # ty: ignore[unresolved-attribute]
-        if not (
-            isinstance(asset_cls, type) and issubclass(asset_cls, NodeGroupBuilder)
-        ):
-            raise TypeError(f"{file}: ASSET is not a node-group class: {asset_cls!r}")
-        # Merged typed-API classes are Asset*Groups that would *append* their
-        # own .blend; building from source is the whole point here.
-        with build_from_source():
-            tree = asset_cls.create_group()
-        if tree.asset_data is None:
-            tree.asset_mark()
-        asset_data = tree.asset_data
-        assert asset_data is not None
-        metadata = getattr(module, "ASSET_METADATA", {})
-        assert isinstance(metadata, dict)
-        for field in _METADATA_FIELDS:
-            if field in metadata:
+    # A dumped module's recipe leaves TreeBuilder at its default arrangement,
+    # which resolves through this scoped default (snapshot-positions modules
+    # disable arrangement and are unaffected).
+    options = arrange
+    if add_reroutes:
+        options = replace(options or SugiyamaOptions(), add_reroutes=True)
+    arrange_override = (
+        default_sugiyama_options(options) if options is not None else nullcontext()
+    )
+    with arrange_override:
+        # Materials first: asset trees look them up by name while building.
+        built_materials = []
+        for file, module in material_modules:
+            material_cls = module.MATERIAL  # ty: ignore[unresolved-attribute]
+            if not (
+                isinstance(material_cls, type)
+                and issubclass(material_cls, NodeGroupBuilder)
+            ):
+                raise TypeError(f"{file}: MATERIAL is not a node-group class")
+            name = getattr(module, "MATERIAL_NAME", None) or material_cls._name
+            # The material recipe may instantiate typed-API asset classes, which
+            # must build from their _build_group source, not append.
+            with build_from_source():
+                material = _build_material(material_cls, name)
+            for key, value in getattr(module, "MATERIAL_PROPERTIES", {}).items():
                 try:
-                    setattr(asset_data, field, metadata[field])
-                except AttributeError:  # pragma: no cover - other Blender versions
-                    # Read-only in this Blender version (as catalog_simple_name
-                    # was) — the value is derived, not lost; keep building.
-                    print(f"  {tree.name}: skipping read-only asset field {field!r}")
-        existing_tags = {tag.name for tag in asset_data.tags}
-        for tag in metadata.get("tags", ()):
-            if tag not in existing_tags:
-                asset_data.tags.new(tag)
-        properties = getattr(module, "TREE_PROPERTIES", {})
-        assert isinstance(properties, dict)
-        for key, value in properties.items():
-            setattr(tree, key, value)
-        trees.append(tree)
+                    setattr(material, key, value)
+                except AttributeError:
+                    print(f"  {name}: skipping read-only material property {key!r}")
+            built_materials.append(material)
+
+        trees = []
+        for file, module in asset_modules:
+            asset_cls = module.ASSET  # ty: ignore[unresolved-attribute]
+            if not (
+                isinstance(asset_cls, type) and issubclass(asset_cls, NodeGroupBuilder)
+            ):
+                raise TypeError(
+                    f"{file}: ASSET is not a node-group class: {asset_cls!r}"
+                )
+            # Merged typed-API classes are Asset*Groups that would *append* their
+            # own .blend; building from source is the whole point here.
+            with build_from_source():
+                tree = asset_cls.create_group()
+            if tree.asset_data is None:
+                tree.asset_mark()
+            asset_data = tree.asset_data
+            assert asset_data is not None
+            metadata = getattr(module, "ASSET_METADATA", {})
+            assert isinstance(metadata, dict)
+            for field in _METADATA_FIELDS:
+                if field in metadata:
+                    try:
+                        setattr(asset_data, field, metadata[field])
+                    except AttributeError:  # pragma: no cover - other Blender versions
+                        # Read-only in this Blender version (as catalog_simple_name
+                        # was) — the value is derived, not lost; keep building.
+                        print(
+                            f"  {tree.name}: skipping read-only asset field {field!r}"
+                        )
+            existing_tags = {tag.name for tag in asset_data.tags}
+            for tag in metadata.get("tags", ()):
+                if tag not in existing_tags:
+                    asset_data.tags.new(tag)
+            properties = getattr(module, "TREE_PROPERTIES", {})
+            assert isinstance(properties, dict)
+            for key, value in properties.items():
+                setattr(tree, key, value)
+            trees.append(tree)
 
     # Placeholders satisfied the lookups during the build; deleting them nulls
     # the referencing socket defaults, which is exactly what "drop" means.
@@ -1149,6 +1186,187 @@ def build_library(
     return [tree.name for tree in trees]
 
 
+def plot_library(
+    blend_path: str | Path,
+    output_dir: str | Path,
+    names: Iterable[str] | None = None,
+    *,
+    dpi: int = 150,
+    arrange: SugiyamaOptions | None = None,
+) -> dict[str, Path]:
+    """Render node groups from ``blend_path`` to PNG images under
+    ``output_dir`` — a headless look at node graphs, e.g. for posting in
+    pull requests (``python -m nodebpy.assets plot``).
+
+    ``names`` selects the groups to plot: exact names or :mod:`fnmatch`
+    wildcard patterns (``"Style *"``), matched against *every* node group in
+    the ``.blend`` (not just assets); ``None`` plots them all. A pattern
+    matching nothing raises. Each tree is drawn with
+    :func:`nodebpy.export.to_plot` (which needs the optional ``matplotlib``
+    dependency) at its stored layout, or re-arranged first when ``arrange``
+    options are given. Everything appended for plotting is removed from the
+    session again afterwards.
+
+    Returns
+    -------
+    dict[str, Path]
+        Mapping of group name to the image it was written to.
+    """
+    blend_path = Path(blend_path)
+    output_dir = Path(output_dir)
+    if not blend_path.is_file():
+        raise FileNotFoundError(f"Asset library not found: {blend_path.resolve()}")
+
+    from ..builder.layout import arrange as arrange_tree_nodes
+    from ..export import to_plot
+
+    patterns = list(names) if names is not None else None
+    before = {
+        coll: set(getattr(bpy.data, coll).keys()) for coll in _CLEANUP_COLLECTIONS
+    }
+    with bpy.data.libraries.load(  # ty: ignore[invalid-context-manager]
+        str(blend_path), link=False
+    ) as (src, dst):
+        available = list(src.node_groups)
+        if patterns is None:
+            wanted = available
+        else:
+            wanted = [
+                n for n in available if any(fnmatch.fnmatchcase(n, p) for p in patterns)
+            ]
+            unmatched = [
+                p
+                for p in patterns
+                if not any(fnmatch.fnmatchcase(n, p) for n in available)
+            ]
+            if unmatched:
+                raise KeyError(f"No node groups in {blend_path} match: {unmatched}")
+        clashes = sorted(n for n in wanted if n in bpy.data.node_groups)
+        if clashes:
+            raise RuntimeError(
+                f"Node groups already exist in this session: {clashes}. "
+                "Appending would rename them — plot from a fresh session "
+                "(e.g. python -m nodebpy.assets plot)."
+            )
+        dst.node_groups = list(wanted)
+    added = {
+        coll: [db for db in getattr(bpy.data, coll) if db.name not in before[coll]]
+        for coll in _CLEANUP_COLLECTIONS
+    }
+
+    try:
+        output_dir.mkdir(parents=True, exist_ok=True)
+        written: dict[str, Path] = {}
+        for tree in dst.node_groups:
+            assert tree is not None
+            if arrange is not None:
+                arrange_tree_nodes(tree, arrange)
+            slug = re.sub(r"[^A-Za-z0-9._-]+", "_", tree.name).lstrip(".") or "tree"
+            written[tree.name] = to_plot(tree, output_dir / f"{slug}.png", dpi=dpi)
+    finally:
+        for coll in _CLEANUP_COLLECTIONS:
+            data = getattr(bpy.data, coll)
+            for db in added[coll]:
+                data.remove(db)
+    return written
+
+
+def _add_arrangement_flags(parser, description: str) -> None:  # pragma: no cover
+    """Attach the shared arrangement flag group (one per SugiyamaOptions
+    field, plus --add-reroutes) to a CLI subparser."""
+    layout = parser.add_argument_group("arrangement", description=description)
+    layout.add_argument(
+        "--add-reroutes",
+        action="store_true",
+        help=(
+            "Arrange with reroute nodes inserted to route long links around "
+            "nodes (the node-arrange addon's behaviour)."
+        ),
+    )
+    layout.add_argument(
+        "--spacing",
+        nargs=2,
+        type=float,
+        metavar=("X", "Y"),
+        help="Horizontal and vertical space between nodes (default: 30 30).",
+    )
+    layout.add_argument(
+        "--iterations",
+        type=int,
+        help=(
+            "Number of iterations spent reducing crossings between links "
+            "(higher gives fewer crossings, but is slower; default: 50)."
+        ),
+    )
+    layout.add_argument(
+        "--direction",
+        type=str.upper,
+        choices=["LEFT_DOWN", "RIGHT_DOWN", "LEFT_UP", "RIGHT_UP", "BALANCED"],
+        help=(
+            "Direction of layout — which corner nodes align towards, or "
+            "'balanced' to even out the four extremes (default: right_up)."
+        ),
+    )
+    layout.add_argument(
+        "--socket-alignment",
+        type=str.upper,
+        choices=["NONE", "MODERATE", "FULL"],
+        help=(
+            "How aggressively links are straightened by aligning the sockets "
+            "they connect (default: none)."
+        ),
+    )
+    layout.add_argument(
+        "--keep-reroutes-outside-frames",
+        action="store_true",
+        help="Do not place added reroutes inside frames.",
+    )
+    layout.add_argument(
+        "--no-stack-collapsed",
+        dest="stack_collapsed",
+        action="store_false",
+        help="Do not stack consecutive collapsed nodes tightly.",
+    )
+    layout.add_argument(
+        "--stack-margin-y-fac",
+        type=float,
+        help=(
+            "Fraction of the vertical spacing used between stacked collapsed "
+            "nodes (default: 0.5)."
+        ),
+    )
+    layout.add_argument(
+        "--optimize-sizes",
+        action="store_true",
+        help="Fit the widths of collapsed nodes to their display name.",
+    )
+
+
+def _arrange_options_from_args(args) -> SugiyamaOptions | None:
+    """The build CLI's arrangement override: a :class:`SugiyamaOptions` with
+    every provided layout flag applied, or None when all are left unset (so
+    the build runs with the plain defaults, overridable further in-process).
+    ``--add-reroutes`` is composed separately by :func:`build_library`."""
+    overrides: dict = {}
+    if args.spacing is not None:
+        overrides["margin"] = tuple(args.spacing)
+    if args.iterations is not None:
+        overrides["iterations"] = args.iterations
+    if args.direction is not None:
+        overrides["direction"] = args.direction
+    if args.socket_alignment is not None:
+        overrides["socket_alignment"] = args.socket_alignment
+    if args.keep_reroutes_outside_frames:
+        overrides["keep_reroutes_outside_frames"] = True
+    if not args.stack_collapsed:
+        overrides["stack_collapsed"] = False
+    if args.stack_margin_y_fac is not None:
+        overrides["stack_margin_y_fac"] = args.stack_margin_y_fac
+    if args.optimize_sizes:
+        overrides["optimize_sizes"] = True
+    return SugiyamaOptions(**overrides) if overrides else None
+
+
 def main(argv: list[str] | None = None) -> None:  # pragma: no cover - CLI wrapper
     """CLI entry point for the ``dump`` and ``build`` subcommands."""
     import argparse
@@ -1262,6 +1480,12 @@ def main(argv: list[str] | None = None) -> None:  # pragma: no cover - CLI wrapp
             "objects, …) from, by name, before building."
         ),
     )
+    _add_arrangement_flags(
+        build,
+        "Tune the automatic layout of the built trees (the SugiyamaOptions "
+        "defaults apply where unset). Sources dumped with "
+        "--snapshot-positions keep their authored layout regardless.",
+    )
     build.add_argument(
         "--drop-missing",
         dest="on_missing",
@@ -1276,6 +1500,44 @@ def main(argv: list[str] | None = None) -> None:  # pragma: no cover - CLI wrapp
         ),
     )
 
+    plot = sub.add_parser(
+        "plot",
+        help="Render node groups from a .blend to PNG images.",
+        description=(
+            "Render node groups from a .blend to PNG images — a headless "
+            "look at node graphs, e.g. for posting in pull requests. Selects "
+            "groups by exact name or fnmatch wildcard ('Style *'), matched "
+            "against every node group in the file (not just assets); with no "
+            "names, every group is plotted. Trees are drawn at their stored "
+            "layout unless --arrange (or any arrangement flag) is given. "
+            "Requires matplotlib (pip install nodebpy[plot])."
+        ),
+    )
+    plot.add_argument("blend", type=Path, help="The .blend holding the node groups.")
+    plot.add_argument("output", type=Path, help="Directory to write the .png files to.")
+    plot.add_argument(
+        "names",
+        nargs="*",
+        help=(
+            "Group names to plot; fnmatch wildcards supported ('Style *', "
+            "quoted to keep the shell from expanding them). Default: all."
+        ),
+    )
+    plot.add_argument("--dpi", type=int, default=150, help="Image DPI (default: 150).")
+    plot.add_argument(
+        "--arrange",
+        action="store_true",
+        help=(
+            "Re-arrange each tree before plotting instead of drawing its "
+            "stored layout (implied by any arrangement flag below)."
+        ),
+    )
+    _add_arrangement_flags(
+        plot,
+        "Tune the re-arrangement applied before plotting; passing any of "
+        "these implies --arrange.",
+    )
+
     args = parser.parse_args(argv)
     if args.command == "dump":
         written = dump_library(
@@ -1291,6 +1553,23 @@ def main(argv: list[str] | None = None) -> None:  # pragma: no cover - CLI wrapp
         for name, path in written.items():
             print(f"  {name}: {path}")
         print(f"Dumped {len(written)} assets to {args.output}")
+    elif args.command == "plot":
+        options = _arrange_options_from_args(args)
+        method: SugiyamaOptions | None = None
+        if args.arrange or args.add_reroutes or options is not None:
+            method = options or SugiyamaOptions()
+            if args.add_reroutes:
+                method = replace(method, add_reroutes=True)
+        written = plot_library(
+            args.blend,
+            args.output,
+            args.names or None,
+            dpi=args.dpi,
+            arrange=method,
+        )
+        for name, path in written.items():
+            print(f"  {name}: {path}")
+        print(f"Plotted {len(written)} node groups to {args.output}")
     else:
         names = build_library(
             args.source,
@@ -1299,6 +1578,8 @@ def main(argv: list[str] | None = None) -> None:  # pragma: no cover - CLI wrapp
             allow_existing=args.allow_existing,
             resources=args.resources,
             on_missing=args.on_missing,
+            add_reroutes=args.add_reroutes,
+            arrange=_arrange_options_from_args(args),
         )
         print(f"Built {args.blend} with {len(names)} assets: {', '.join(names)}")
 

{nodebpy-520.18.0 → nodebpy-520.19.0}/src/nodebpy/builder/__init__.py

@@ -11,6 +11,14 @@ from .asset import (
     build_from_source,
 )
 from .items import Item, ItemsMixin, MenuItem
+from .layout import (
+    ArrangeMethod,
+    SimpleOptions,
+    SugiyamaOptions,
+    arrange,
+    arrange_tree,
+    default_sugiyama_options,
+)
 from .mixins import LinkingMixin, OperatorMixin
 from .node import (
     BaseNode,
@@ -76,6 +84,7 @@ from .tree import (
 )
 
 __all__ = [
+    "ArrangeMethod",
     "AssetCompositorGroup",
     "AssetGeometryGroup",
     "AssetLibrary",
@@ -133,6 +142,7 @@ __all__ = [
     "RotationSocketList",
     "ShaderSocket",
     "ShaderSocketList",
+    "SimpleOptions",
     "Socket",
     "SocketAccessor",
     "SocketContext",
@@ -141,12 +151,16 @@ __all__ = [
     "SoundSocketList",
     "StringSocket",
     "StringSocketList",
+    "SugiyamaOptions",
     "TreeBuilder",
     "VectorSocket",
     "VectorSocketGrid",
     "VectorSocketList",
+    "arrange",
+    "arrange_tree",
     "asset_group_base",
     "build_from_source",
+    "default_sugiyama_options",
     "denormalize_name",
     "normalize_name",
 ]