nodebpy 520.21.0__tar.gz → 520.23.0__tar.gz

{nodebpy-520.21.0 → nodebpy-520.23.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.21.0
+Version: 520.23.0
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>

{nodebpy-520.21.0 → nodebpy-520.23.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.21.0"
+version = "520.23.0"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/__init__.py

@@ -5,6 +5,7 @@ from .builder import (
     SugiyamaOptions,
     TreeBuilder,
     arrange,
+    default_split_inputs,
     default_sugiyama_options,
 )
 from .nodes import compositor, geometry, shader
@@ -17,6 +18,7 @@ __all__ = [
     "arrange",
     "builder",
     "compositor",
+    "default_split_inputs",
     "default_sugiyama_options",
     "export",
     "geometry",

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/assets/_library.py

@@ -88,6 +88,7 @@ from ..builder import (
     SugiyamaOptions,
     TreeBuilder,
     build_from_source,
+    default_split_inputs,
     default_sugiyama_options,
 )
 from ..builder._utils import normalize_name
@@ -1062,6 +1063,7 @@ def build_library(
     on_missing: str = "error",
     add_reroutes: bool = False,
     arrange: SugiyamaOptions | None = None,
+    split_inputs: bool = False,
 ) -> list[str]:
     """Rebuild a ``.blend`` asset library from sources written by
     :func:`dump_library`.
@@ -1094,9 +1096,14 @@ def build_library(
     :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.
+    ``split_inputs=True`` gives each consumer node its own Group Input
+    instance — named and labelled after the interface sockets it carries,
+    with unused sockets hidden — instead of a single Group Input trailing
+    long noodles (scoped via
+    :func:`nodebpy.builder.default_split_inputs`). All three only affect
+    modules that leave the arrangement at its default — sources dumped with
+    ``snapshot_positions`` disable arrangement and keep their authored
+    layout, authored Group Input splits included.
 
     The built trees stay in the current session afterwards. Because
     ``create_group()`` reuses an existing tree of the same name (that is what
@@ -1193,7 +1200,8 @@ def build_library(
     arrange_override = (
         default_sugiyama_options(options) if options is not None else nullcontext()
     )
-    with arrange_override:
+    split_override = default_split_inputs() if split_inputs else nullcontext()
+    with arrange_override, split_override:
         # Materials first: asset trees look them up by name while building.
         built_materials = []
         for file, module in material_modules:
@@ -1521,6 +1529,17 @@ def _add_build_flags(parser) -> None:  # pragma: no cover
         "defaults apply where unset). Sources dumped with "
         "--snapshot-positions keep their authored layout regardless.",
     )
+    parser.add_argument(
+        "--split-inputs",
+        action="store_true",
+        help=(
+            "Give each consumer node its own Group Input instance, named "
+            "after the interface sockets it uses (unused sockets hidden), "
+            "instead of one Group Input trailing long noodles. Sources "
+            "dumped with --snapshot-positions keep their authored layout "
+            "regardless."
+        ),
+    )
     parser.add_argument(
         "--drop-missing",
         dest="on_missing",
@@ -1784,6 +1803,7 @@ def _build_command(args) -> None:
         on_missing=args.on_missing,
         add_reroutes=args.add_reroutes,
         arrange=_arrange_options_from_args(args),
+        split_inputs=args.split_inputs,
     )
     print(f"Built {args.blend} with {len(names)} assets: {', '.join(names)}")
     write_stamp(args.blend, args.source, args.resources, stamp_options(args))

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/assets/_pipeline.py

@@ -88,6 +88,7 @@ _CONFIG_KEYS: dict[str, tuple[str | None, str]] = {
     "no-compress": ("compress", "off"),
     "drop-missing": ("on_missing", "drop"),
     "add-reroutes": ("add_reroutes", "flag"),
+    "split-inputs": ("split_inputs", "flag"),
     "spacing": ("spacing", "value"),
     "iterations": ("iterations", "value"),
     "direction": ("direction", "value"),
@@ -122,6 +123,7 @@ _OPTION_DEFAULTS: dict[str, object] = {
     "compress": True,
     "on_missing": "error",
     "add_reroutes": False,
+    "split_inputs": False,
     "spacing": None,
     "iterations": None,
     "direction": None,
@@ -150,6 +152,7 @@ _STAMP_DESTS = (
     "snapshot_positions",
     "socket_alignment",
     "spacing",
+    "split_inputs",
     "stack_collapsed",
     "stack_margin_y_fac",
     "typed_api",
@@ -345,6 +348,8 @@ def _build_stage_flags(args: Namespace) -> list[str]:
         flags.append("--no-compress")
     if args.add_reroutes:
         flags.append("--add-reroutes")
+    if args.split_inputs:
+        flags.append("--split-inputs")
     if args.spacing is not None:
         flags += ["--spacing", *(str(value) for value in args.spacing)]
     if args.iterations is not None:

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/builder/__init__.py

@@ -17,6 +17,7 @@ from .layout import (
     SugiyamaOptions,
     arrange,
     arrange_tree,
+    default_split_inputs,
     default_sugiyama_options,
 )
 from .mixins import LinkingMixin, OperatorMixin
@@ -160,6 +161,7 @@ __all__ = [
     "arrange_tree",
     "asset_group_base",
     "build_from_source",
+    "default_split_inputs",
     "default_sugiyama_options",
     "denormalize_name",
     "normalize_name",

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/builder/layout.py

@@ -512,6 +512,32 @@ def default_sugiyama_options(options: SugiyamaOptions) -> Iterator[None]:
         _DEFAULT_SUGIYAMA.reset(token)
 
 
+# What TreeBuilder's split_inputs=None resolves to. Overridable per scope so
+# a batch build can split the Group Input of trees whose recipes leave
+# TreeBuilder at its default — see :func:`default_split_inputs`.
+_DEFAULT_SPLIT_INPUTS: ContextVar[bool] = ContextVar(
+    "nodebpy_default_split_inputs", default=False
+)
+
+
+@contextmanager
+def default_split_inputs(split: bool = True) -> Iterator[None]:
+    """Scope in which every ``TreeBuilder`` left at its default
+    ``split_inputs`` splits the Group Input node into one instance per
+    consumer node (with unused sockets hidden) on context exit.
+
+    An explicit ``split_inputs=True/False`` is unaffected, and so are trees
+    that disable auto-arrangement (as ``snapshot_positions`` dumps do) —
+    their authored layout, including any authored Group Input splits, must
+    survive untouched.
+    """
+    token = _DEFAULT_SPLIT_INPUTS.set(split)
+    try:
+        yield
+    finally:
+        _DEFAULT_SPLIT_INPUTS.reset(token)
+
+
 def _arrange_sugiyama(tree: bpy.types.NodeTree, options: SugiyamaOptions) -> None:
     from mathutils import Vector
 

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/builder/tree.py

@@ -31,7 +31,7 @@ from ._utils import (
     resolve_socket_key,
     socket_key,
 )
-from .layout import ArrangeMethod
+from .layout import _DEFAULT_SPLIT_INPUTS, ArrangeMethod
 from .layout import arrange as _arrange_nodes
 from .socket import (
     BooleanSocket,
@@ -1106,7 +1106,7 @@ class TreeBuilder[TreeT: NodeTree]:
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
         ignore_visibility: bool = False,
-        split_inputs: bool = False,
+        split_inputs: bool | None = None,
     ):
         if isinstance(tree, str):
             self.tree = bpy.data.node_groups.new(tree, tree_type)  # ty: ignore[invalid-assignment]
@@ -1131,7 +1131,7 @@ class TreeBuilder[TreeT: NodeTree]:
         collapse: bool = False,
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
-        split_inputs: bool = False,
+        split_inputs: bool | None = None,
     ) -> TreeBuilder[GeometryNodeTree]:
         """Create a geometry node tree."""
         return cast(
@@ -1154,7 +1154,7 @@ class TreeBuilder[TreeT: NodeTree]:
         collapse: bool = False,
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
-        split_inputs: bool = False,
+        split_inputs: bool | None = None,
     ) -> TreeBuilder[ShaderNodeTree]:
         """Create a shader node tree."""
         return cast(
@@ -1177,7 +1177,7 @@ class TreeBuilder[TreeT: NodeTree]:
         collapse: bool = False,
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
-        split_inputs: bool = False,
+        split_inputs: bool | None = None,
     ) -> TreeBuilder[CompositorNodeTree]:
         """Create a compositor node tree."""
         return cast(
@@ -1268,7 +1268,14 @@ class TreeBuilder[TreeT: NodeTree]:
     def __exit__(self, *args):
         # Split before auto-layout, so the created instances get arranged
         # next to their consumers.
-        if self._split_inputs:
+        split = self._split_inputs
+        if split is None:
+            # The ambient default (see default_split_inputs) only reaches
+            # auto-arranged trees: snapshot-positions dumps disable
+            # arrangement and their authored layout — including any authored
+            # Group Input splits — must survive untouched.
+            split = self._arrange is not None and _DEFAULT_SPLIT_INPUTS.get()
+        if split:
             self.split_group_inputs()
         if self._arrange is not None:
             self.arrange()
@@ -1425,10 +1432,11 @@ class TreeBuilder[TreeT: NodeTree]:
     @property
     def group_input_splits(self) -> list[dict]:
         """The extra Group Input instances beyond the primary one, each as
-        ``{"name": ..., "links": [(interface input name, consumer node name,
-        consumer socket key), ...], "location": ..., "parent": ...}`` — the
-        editor convention of several input nodes near their consumers
-        instead of one node trailing long noodles. See the setter."""
+        ``{"name": ..., "label": ..., "links": [(interface input name,
+        consumer node name, consumer socket key), ...], "location": ...,
+        "parent": ...}`` — the editor convention of several input nodes near
+        their consumers instead of one node trailing long noodles. See the
+        setter."""
         splits: list[dict] = []
         for node in self.tree.nodes:
             if node.bl_idname != "NodeGroupInput" or node.name == "Group Input":
@@ -1442,6 +1450,7 @@ class TreeBuilder[TreeT: NodeTree]:
             splits.append(
                 {
                     "name": node.name,
+                    "label": node.label,
                     "links": links,
                     "location": (node.location.x, node.location.y),
                     "parent": node.parent.name if node.parent is not None else None,
@@ -1469,6 +1478,8 @@ class TreeBuilder[TreeT: NodeTree]:
             instance = self.tree.nodes.new("NodeGroupInput")
             assert instance is not None
             instance.name = split["name"]
+            if label := split.get("label"):
+                instance.label = label
             # Authored placement (parent before location — locations are
             # parent-relative); older snapshots without these keys leave the
             # instance where auto-layout or the caller puts it.
@@ -1533,10 +1544,15 @@ class TreeBuilder[TreeT: NodeTree]:
     def split_group_inputs(self) -> None:
         """Split the Group Input node into one instance per consumer node,
         with unused sockets hidden — regenerating the editor style that
-        avoids a single input node trailing long noodles. Runs automatically
-        on context exit (before auto-layout, so the instances are arranged
-        next to their consumers) when the builder was created with
-        ``split_inputs=True``."""
+        avoids a single input node trailing long noodles. Each instance is
+        named (and labelled, so the editor header shows it) after the
+        interface sockets it carries, making it easy to spot when scanning
+        the tree (Blender de-duplicates repeated names with ``.001``
+        suffixes as usual), and parented into its consumer's frame so the
+        arranger's frame clustering keeps the pair together. Runs automatically on context exit (before auto-layout, so
+        the instances are arranged next to their consumers) when the builder
+        was created with ``split_inputs=True``, or inside a
+        :func:`~nodebpy.builder.default_split_inputs` scope."""
         primary = self.tree.nodes.get("Group Input")
         if primary is None:
             return
@@ -1546,11 +1562,27 @@ class TreeBuilder[TreeT: NodeTree]:
                 by_consumer.setdefault(link.to_node.name, []).append(
                     (socket.name, link.to_node.name, socket_key(link.to_socket))
                 )
+
+        def socket_names(links: list[tuple[str, str, str]]) -> str:
+            return ", ".join(dict.fromkeys(name for name, _, _ in links))
+
+        def parent_frame(consumer: str) -> str | None:
+            parent = self.tree.nodes[consumer].parent
+            return parent.name if parent is not None else None
+
         # The first consumer keeps the primary node; each further consumer
-        # gets its own instance (named like Blender would on duplication).
+        # gets its own instance, named after the sockets it carries and
+        # parented into the consumer's frame — frame clustering would
+        # otherwise push an unparented instance away from its consumer when
+        # the tree is arranged.
         self.group_input_splits = [
-            {"name": f"Group Input.{index:03d}", "links": by_consumer[consumer]}
-            for index, consumer in enumerate(list(by_consumer)[1:], start=1)
+            {
+                "name": socket_names(by_consumer[consumer]),
+                "label": socket_names(by_consumer[consumer]),
+                "parent": parent_frame(consumer),
+                "links": by_consumer[consumer],
+            }
+            for consumer in list(by_consumer)[1:]
         ]
         self._hide_unused_input_sockets()
 

{nodebpy-520.21.0 → nodebpy-520.23.0}/src/nodebpy/export/codegen.py

@@ -812,6 +812,15 @@ def _make_var(label: str, counter: dict[str, int]) -> str:
     return f"{base}_{counter[base]}"
 
 
+def _node_var_label(node) -> str:
+    """The stem for a node's generated variable name. A group node's
+    ``bl_label`` is just "Group", so it reads as its group's name instead
+    (``inverse_mass = InverseMass()``)."""
+    if node.bl_idname in _GROUP_BASES and node.node_tree is not None:
+        return node.node_tree.name
+    return node.bl_label or "node"
+
+
 # ---------------------------------------------------------------------------
 # Graph utilities
 # ---------------------------------------------------------------------------
@@ -1203,7 +1212,7 @@ class EmitContext:
         vector feeding ``vec.x`` / ``vec.y``). The assignment is queued on
         ``pending_lines`` and flushed before the consuming statement.
         """
-        label = link.from_socket.name or link.from_node.bl_label or "value"
+        label = link.from_socket.name or _node_var_label(link.from_node)
         var = _make_var(label, self.counter)
         self.pending_lines.append(f"    {var} = {expr.render()}")
         ref = Ref(var)
@@ -3930,6 +3939,8 @@ def _group_input_split_lines(
         parent = _fmt(node.parent.name) if node.parent is not None else "None"
         lines.append(f"{indent}    {{")
         lines.append(f'{indent}        "name": {_fmt(node.name)},')
+        if node.label:
+            lines.append(f'{indent}        "label": {_fmt(node.label)},')
         lines.append(f'{indent}        "location": {_fmt(loc)},')
         lines.append(f'{indent}        "parent": {parent},')
         lines.append(f'{indent}        "links": [')
@@ -4489,7 +4500,7 @@ def _emit_tree(node_tree, collector: _GroupCollector) -> _TreeEmission:
                         f"Cannot generate code: {message}. Register an emitter "
                         "with register_emitter() or pass strict=False."
                     )
-                var = _make_var(node.bl_label or "node", ctx.counter)
+                var = _make_var(_node_var_label(node), ctx.counter)
                 if not ctx.outgoing.get(name):
                     var = "_" + var
                 ctx.var_map[name] = _Val(Ref(var))
@@ -4575,7 +4586,7 @@ def _emit_tree(node_tree, collector: _GroupCollector) -> _TreeEmission:
             consumed_out_links.add(id(link))
             continue
 
-        var = _make_var(node.bl_label or "node", ctx.counter)
+        var = _make_var(_node_var_label(node), ctx.counter)
         # A node created purely for its side effect (a gizmo, a dangling
         # node) is never referenced again — prefix its variable so the
         # generated module passes lint (F841).