nodebpy 0.7.2__tar.gz → 0.8.0__tar.gz

{nodebpy-0.7.2 → nodebpy-0.8.0}/PKG-INFO

@@ -1,13 +1,13 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.7.2
+Version: 0.8.0
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
-Requires-Dist: networkx>=3.6.1
 Requires-Dist: bpy>=5.0.1 ; extra == 'bpy'
 Requires-Dist: fake-bpy-module>=20260113 ; extra == 'dev'
 Requires-Dist: jsondiff>=2.2.1 ; extra == 'dev'
+Requires-Dist: networkx>=3.6.1 ; extra == 'dev'
 Requires-Dist: pytest>=9.0.2 ; extra == 'dev'
 Requires-Dist: pytest-cov>=7.0.0 ; extra == 'dev'
 Requires-Dist: quarto-cli>=1.8.26 ; extra == 'dev'
@@ -16,10 +16,12 @@ Requires-Dist: ruff>=0.14.11 ; extra == 'dev'
 Requires-Dist: syrupy>=5.0.0 ; extra == 'dev'
 Requires-Dist: tree-clipper>=0.1.1 ; extra == 'dev'
 Requires-Dist: ipython>=8.0.0 ; extra == 'jupyter'
+Requires-Dist: networkx>=3.6.1 ; extra == 'networkx'
 Requires-Python: >=3.11
 Provides-Extra: bpy
 Provides-Extra: dev
 Provides-Extra: jupyter
+Provides-Extra: networkx
 Description-Content-Type: text/markdown
 
 
@@ -57,9 +59,9 @@ In `nodebpy` we use the `>>` operator to link from one node or socket into anoth
 This should feel and behave much like the <kbd>Alt</kbd> + <kbd>Right Click</kbd> drag between nodes in [Node Wrangler](https://docs.blender.org/manual/en/latest/addons/node/node_wrangler.html). It will use some smart logic to match the most compatible sockets between the nodes, but if you ever want to be explicit you do so. The input and output sockets of a node are accessible as properties via the `i_*` and `o_*` prefixes, or you can use the `...` placeholder to specify the particular input to be user, or pass in the previous node as a named argument.
 
 ```py
-n.Vector() >> n.SetPosition().i_offset
-n.Vector() >> n.SetPosition(offset=...)
-n.SetPosition(offset=n.Vector())
+g.Vector() >> g.SetPosition().i_offset
+g.Vector() >> g.SetPosition(offset=...)
+g.SetPosition(offset=g.Vector())
 ```
 
 The `>>` operator will always look for the _most_ compatible sockets first (matching data types) before looking for other compatible but not identical socket data types to link.
@@ -76,7 +78,7 @@ Entering the `tree.inputs` and `tree.outputs` contexts will let you add new inte
 
 ```py
 with TreeBuilder("MyTree") as tree:
-    points = n.Points(position=n.RandomValue.vector(min=-1))
+    points = g.Points(position=g.RandomValue.vector(min=-1))
     with tree.outputs:
         points >> s.SocketGeometry("New Points")
 ```
@@ -86,7 +88,7 @@ with TreeBuilder("MyTree") as tree:
 The node tree below creates a integer input and geometry output to the node group. We create a `rotation` variable that can be used later on as an argument, then construct a longer chain of nodes being created and linked together. The nodes are added and linked as each node is instantiated. After we exit the tree context, the nodes are automatically arranged.
 
 ``` python
-from nodebpy import TreeBuilder, nodes as n, sockets as s
+from nodebpy import TreeBuilder, geometry as g, sockets as s
 
 with TreeBuilder("AnotherTree", collapse=True) as tree:
     with tree.inputs:
@@ -95,21 +97,21 @@ with TreeBuilder("AnotherTree", collapse=True) as tree:
         instances = s.SocketGeometry("Instances")
 
     rotation = (
-        n.RandomValue.vector(min=-1, seed=2)
-        >> n.AlignRotationToVector()
-        >> n.RotateRotation(rotate_by=n.AxisAngleToRotation(angle=0.3))
+        g.RandomValue.vector(min=-1, seed=2)
+        >> g.AlignRotationToVector()
+        >> g.RotateRotation(rotate_by=g.AxisAngleToRotation(angle=0.3))
     )
 
     _ = (
         count
-        >> n.Points(position=n.RandomValue.vector(min=-1))
-        >> n.InstanceOnPoints(instance=n.Cube(), rotation=rotation)
-        >> n.SetPosition(
-            position=n.Position() * 2.0 + (0, 0.2, 0.3),
+        >> g.Points(position=g.RandomValue.vector(min=-1))
+        >> g.InstanceOnPoints(instance=g.Cube(), rotation=rotation)
+        >> g.SetPosition(
+            position=g.Position() * 2.0 + (0, 0.2, 0.3),
             offset=(0, 0, 0.1),
         )
-        >> n.RealizeInstances()
-        >> n.InstanceOnPoints(n.Cube(), instance=...)
+        >> g.RealizeInstances()
+        >> g.InstanceOnPoints(g.Cube(), instance=...)
         >> instances
     )
 ```
@@ -126,16 +128,16 @@ The basic math operators also automatically add relevant nodes with their operat
 
 ```py
 # operation is exposed as a property
-math = n.Math(1.0, 2.0, operation='ADD')
+math = g.Math(1.0, 2.0, operation='ADD')
 math.operation = "SUBTRACT"
 
 # operation can be chose as a class method
-math = n.Math.subtract(1.0, 2.0)
-math = n.Math.add(1.0, 2.0)
+math = g.Math.subtract(1.0, 2.0)
+math = g.Math.add(1.0, 2.0)
 
-# these are equivalent, the n.Math.multiply is automatically added
-n.Value(1.0) * 2
-n.Math.multiply(n.Value(1.0), 2.0)
+# these are equivalent, the g.Math.multiply is automatically added
+g.Value(1.0) * 2
+g.Math.multiply(g.Value(1.0), 2.0)
 ```
 
 # Design Considerations

{nodebpy-0.7.2 → nodebpy-0.8.0}/README.md

@@ -33,9 +33,9 @@ In `nodebpy` we use the `>>` operator to link from one node or socket into anoth
 This should feel and behave much like the <kbd>Alt</kbd> + <kbd>Right Click</kbd> drag between nodes in [Node Wrangler](https://docs.blender.org/manual/en/latest/addons/node/node_wrangler.html). It will use some smart logic to match the most compatible sockets between the nodes, but if you ever want to be explicit you do so. The input and output sockets of a node are accessible as properties via the `i_*` and `o_*` prefixes, or you can use the `...` placeholder to specify the particular input to be user, or pass in the previous node as a named argument.
 
 ```py
-n.Vector() >> n.SetPosition().i_offset
-n.Vector() >> n.SetPosition(offset=...)
-n.SetPosition(offset=n.Vector())
+g.Vector() >> g.SetPosition().i_offset
+g.Vector() >> g.SetPosition(offset=...)
+g.SetPosition(offset=g.Vector())
 ```
 
 The `>>` operator will always look for the _most_ compatible sockets first (matching data types) before looking for other compatible but not identical socket data types to link.
@@ -52,7 +52,7 @@ Entering the `tree.inputs` and `tree.outputs` contexts will let you add new inte
 
 ```py
 with TreeBuilder("MyTree") as tree:
-    points = n.Points(position=n.RandomValue.vector(min=-1))
+    points = g.Points(position=g.RandomValue.vector(min=-1))
     with tree.outputs:
         points >> s.SocketGeometry("New Points")
 ```
@@ -62,7 +62,7 @@ with TreeBuilder("MyTree") as tree:
 The node tree below creates a integer input and geometry output to the node group. We create a `rotation` variable that can be used later on as an argument, then construct a longer chain of nodes being created and linked together. The nodes are added and linked as each node is instantiated. After we exit the tree context, the nodes are automatically arranged.
 
 ``` python
-from nodebpy import TreeBuilder, nodes as n, sockets as s
+from nodebpy import TreeBuilder, geometry as g, sockets as s
 
 with TreeBuilder("AnotherTree", collapse=True) as tree:
     with tree.inputs:
@@ -71,21 +71,21 @@ with TreeBuilder("AnotherTree", collapse=True) as tree:
         instances = s.SocketGeometry("Instances")
 
     rotation = (
-        n.RandomValue.vector(min=-1, seed=2)
-        >> n.AlignRotationToVector()
-        >> n.RotateRotation(rotate_by=n.AxisAngleToRotation(angle=0.3))
+        g.RandomValue.vector(min=-1, seed=2)
+        >> g.AlignRotationToVector()
+        >> g.RotateRotation(rotate_by=g.AxisAngleToRotation(angle=0.3))
     )
 
     _ = (
         count
-        >> n.Points(position=n.RandomValue.vector(min=-1))
-        >> n.InstanceOnPoints(instance=n.Cube(), rotation=rotation)
-        >> n.SetPosition(
-            position=n.Position() * 2.0 + (0, 0.2, 0.3),
+        >> g.Points(position=g.RandomValue.vector(min=-1))
+        >> g.InstanceOnPoints(instance=g.Cube(), rotation=rotation)
+        >> g.SetPosition(
+            position=g.Position() * 2.0 + (0, 0.2, 0.3),
             offset=(0, 0, 0.1),
         )
-        >> n.RealizeInstances()
-        >> n.InstanceOnPoints(n.Cube(), instance=...)
+        >> g.RealizeInstances()
+        >> g.InstanceOnPoints(g.Cube(), instance=...)
         >> instances
     )
 ```
@@ -102,16 +102,16 @@ The basic math operators also automatically add relevant nodes with their operat
 
 ```py
 # operation is exposed as a property
-math = n.Math(1.0, 2.0, operation='ADD')
+math = g.Math(1.0, 2.0, operation='ADD')
 math.operation = "SUBTRACT"
 
 # operation can be chose as a class method
-math = n.Math.subtract(1.0, 2.0)
-math = n.Math.add(1.0, 2.0)
+math = g.Math.subtract(1.0, 2.0)
+math = g.Math.add(1.0, 2.0)
 
-# these are equivalent, the n.Math.multiply is automatically added
-n.Value(1.0) * 2
-n.Math.multiply(n.Value(1.0), 2.0)
+# these are equivalent, the g.Math.multiply is automatically added
+g.Value(1.0) * 2
+g.Math.multiply(g.Value(1.0), 2.0)
 ```
 
 # Design Considerations

{nodebpy-0.7.2 → nodebpy-0.8.0}/pyproject.toml

@@ -1,20 +1,21 @@
 [project]
 name = "nodebpy"
-version = "0.7.2"
+version = "0.8.0"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
     { name = "Brady Johnston", email = "brady.johnston@me.com" }
 ]
 requires-python = ">=3.11"
-dependencies = [
-    "networkx>=3.6.1",
-]
+dependencies = []
 
 [project.scripts]
 nodebpy = "nodebpy:main"
 
 [project.optional-dependencies]
+networkx = [
+    "networkx>=3.6.1",
+]
 bpy = [
     "bpy>=5.0.1",
 ]
@@ -24,6 +25,7 @@ jupyter = [
 dev = [
     "fake-bpy-module>=20260113",
     "jsondiff>=2.2.1",
+    "networkx>=3.6.1",
     "pytest>=9.0.2",
     "pytest-cov>=7.0.0",
     "quarto-cli>=1.8.26",

nodebpy-0.8.0/src/nodebpy/arrange.py

@@ -0,0 +1,336 @@
+from __future__ import annotations
+
+from collections import Counter, deque
+
+import bpy
+
+
+def _is_layoutable(node: bpy.types.Node) -> bool:
+    """Check if a node should be included in column-based layout.
+
+    Frame nodes are containers and reroute nodes are tiny routing helpers;
+    neither should occupy a full column slot.
+    """
+    return node.bl_idname not in ("NodeFrame", "NodeReroute")
+
+
+def build_dependency_graph(
+    tree: bpy.types.NodeTree,
+) -> tuple[dict[bpy.types.Node, set[bpy.types.Node]], Counter]:
+    """Build a graph of node dependencies and count input connections.
+
+    Only layoutable nodes (excluding frames and reroutes) are included.
+    """
+    layoutable = {n for n in tree.nodes if _is_layoutable(n)}
+    dependency_graph: dict[bpy.types.Node, set[bpy.types.Node]] = {
+        node: set() for node in layoutable
+    }
+    socket_input_connection_count: Counter = Counter()
+
+    for link in tree.links:
+        if link.from_node in layoutable and link.to_node in layoutable:
+            dependency_graph[link.from_node].add(link.to_node)
+        socket_input_connection_count[link.to_socket] += 1
+
+    return dependency_graph, socket_input_connection_count
+
+
+def topological_sort(
+    dependency_graph: dict[bpy.types.Node, set[bpy.types.Node]],
+) -> list[bpy.types.Node]:
+    """Sort nodes in topological (dependency) order using Kahn's algorithm."""
+    incoming = {node: 0 for node in dependency_graph}
+    for dependents in dependency_graph.values():
+        for target in dependents:
+            incoming[target] += 1
+
+    queue = deque(node for node, count in incoming.items() if count == 0)
+    result: list[bpy.types.Node] = []
+
+    while queue:
+        current = queue.popleft()
+        result.append(current)
+        for dependent in dependency_graph[current]:
+            incoming[dependent] -= 1
+            if incoming[dependent] == 0:
+                queue.append(dependent)
+
+    return result
+
+
+def organize_into_columns(
+    nodes_in_order: list[bpy.types.Node],
+    dependency_graph: dict[bpy.types.Node, set[bpy.types.Node]],
+) -> list[list[bpy.types.Node]]:
+    """Assign each node to a column based on its furthest dependent."""
+    columns: list[list[bpy.types.Node]] = []
+    column_of: dict[bpy.types.Node, int] = {}
+
+    for node in reversed(nodes_in_order):
+        col = (
+            max(
+                (column_of[dep] for dep in dependency_graph[node]),
+                default=-1,
+            )
+            + 1
+        )
+        column_of[node] = col
+
+        if col == len(columns):
+            columns.append([node])
+        else:
+            columns[col].append(node)
+
+    # reverse so flow goes left-to-right
+    return list(reversed(columns))
+
+
+def calculate_node_dimensions(
+    node: bpy.types.Node,
+    socket_input_connection_count: Counter,
+    interface_scale: float,
+) -> tuple[float, float]:
+    """Calculate the visual dimensions of a node.
+
+    When a node is collapsed (``node.hide is True``) only linked sockets
+    contribute to the height, and header / property / vector-expansion rows
+    are omitted.
+    """
+    HEADER = 20
+    SOCKET = 32
+    HIDDEN_SOCKET = 14
+    HIDDEN_HEADER = 30
+
+    if node.hide:
+        linked_inputs = sum(1 for s in node.inputs if s.enabled and s.is_linked)
+        linked_outputs = sum(1 for s in node.outputs if s.enabled and s.is_linked)
+        visible = max(linked_inputs, linked_outputs, 1)
+        height = (HIDDEN_HEADER + visible * HIDDEN_SOCKET) * interface_scale
+        return node.width, height
+    PROPERTY_ROW = 28
+    VECTOR_EXPANDED = 84
+
+    enabled_inputs = sum(1 for s in node.inputs if s.enabled)
+    enabled_outputs = sum(1 for s in node.outputs if s.enabled)
+
+    # count properties specific to this node type (not inherited)
+    inherited_ids = {
+        prop.identifier
+        for base in type(node).__bases__
+        for prop in base.bl_rna.properties
+    }
+    node_property_count = sum(
+        1 for prop in node.bl_rna.properties if prop.identifier not in inherited_ids
+    )
+
+    # count vector inputs that need expanded UI widgets (not connected)
+    unconnected_vectors = sum(
+        1
+        for s in node.inputs
+        if s.enabled and s.type == "VECTOR" and socket_input_connection_count[s] == 0
+    )
+
+    height = (
+        HEADER
+        + enabled_outputs * SOCKET
+        + node_property_count * PROPERTY_ROW
+        + enabled_inputs * SOCKET
+        + unconnected_vectors * VECTOR_EXPANDED
+    ) * interface_scale
+
+    return node.width, height
+
+
+def _socket_index(socket: bpy.types.NodeSocket) -> int:
+    """Return the index of a socket among its node's enabled sockets."""
+    collection = socket.node.inputs if not socket.is_output else socket.node.outputs
+    idx = 0
+    for s in collection:
+        if s == socket:
+            return idx
+        if s.enabled:
+            idx += 1
+    return idx
+
+
+def _reduce_crossings(
+    columns: list[list[bpy.types.Node]],
+    tree: bpy.types.NodeTree,
+    passes: int = 4,
+) -> None:
+    """Reorder nodes within columns to reduce edge crossings.
+
+    Uses the barycenter heuristic with socket-level precision: for each node
+    compute its weight from the position of the sockets it connects to in the
+    adjacent column, then sort by that weight.  This correctly distinguishes
+    nodes that connect to different sockets on the same target.
+
+    Alternating forward and backward sweeps iteratively improve the ordering.
+    """
+    if len(columns) < 2:
+        return
+
+    layoutable = {n for col in columns for n in col}
+    col_of = {n: ci for ci, col in enumerate(columns) for n in col}
+
+    # Pre-compute per-node link weights towards each adjacent column direction.
+    # For a forward sweep (fixing col i, sorting col i+1), a node in col i+1
+    # cares about its connections INTO col i.  The weight of each connection is
+    # the position of the *node* in the fixed column plus a fractional offset
+    # derived from the socket index, so that multiple links to the same node
+    # produce distinct, correctly ordered weights.
+    #
+    # We store raw (neighbour_node, socket_fraction) pairs per node per
+    # direction and resolve them during each sweep once column order is known.
+
+    # link records: for each layoutable node, collect tuples of
+    #   (neighbour_node, socket_fraction)
+    # keyed by which side the neighbour is on (left or right).
+    left_links: dict[bpy.types.Node, list[tuple[bpy.types.Node, float]]] = {
+        n: [] for n in layoutable
+    }
+    right_links: dict[bpy.types.Node, list[tuple[bpy.types.Node, float]]] = {
+        n: [] for n in layoutable
+    }
+
+    for link in tree.links:
+        src, dst = link.from_node, link.to_node
+        if src not in layoutable or dst not in layoutable:
+            continue
+        src_col, dst_col = col_of[src], col_of[dst]
+        if src_col >= dst_col:
+            continue  # only consider forward edges
+
+        # Weight based on socket position on the neighbour node.
+        # For a node in the right column looking left: the relevant socket is
+        # on the source node (output side).
+        # For a node in the left column looking right: the relevant socket is
+        # on the target node (input side).
+        out_count = max(1, sum(1 for s in src.outputs if s.enabled))
+        in_count = max(1, sum(1 for s in dst.inputs if s.enabled))
+        src_frac = _socket_index(link.from_socket) / out_count
+        dst_frac = _socket_index(link.to_socket) / in_count
+
+        # dst looks left towards src: weight by src's output socket position
+        left_links[dst].append((src, src_frac))
+        # src looks right towards dst: weight by dst's input socket position
+        right_links[src].append((dst, dst_frac))
+
+    for iteration in range(passes):
+        if iteration % 2 == 0:
+            # forward sweep: fix column i, sort column i+1
+            col_range = range(1, len(columns))
+        else:
+            # backward sweep: fix column i, sort column i-1
+            col_range = range(len(columns) - 2, -1, -1)
+
+        for ci in col_range:
+            if iteration % 2 == 0:
+                fixed_col = columns[ci - 1]
+                links_map = left_links
+            else:
+                fixed_col = columns[ci + 1]
+                links_map = right_links
+
+            pos_in_fixed = {node: idx for idx, node in enumerate(fixed_col)}
+            original_pos = {node: float(idx) for idx, node in enumerate(columns[ci])}
+
+            barycenters: dict[bpy.types.Node, float] = {}
+            for node in columns[ci]:
+                weights = [
+                    pos_in_fixed[nb] + frac
+                    for nb, frac in links_map[node]
+                    if nb in pos_in_fixed
+                ]
+                if weights:
+                    barycenters[node] = sum(weights) / len(weights)
+                else:
+                    barycenters[node] = original_pos[node]
+
+            columns[ci].sort(key=lambda n: barycenters[n])
+
+
+def position_nodes_in_columns(
+    columns: list[list[bpy.types.Node]],
+    connection_counts: Counter,
+    spacing: tuple[float, float] = (50, 25),
+) -> None:
+    """Position nodes column-by-column with the given spacing.
+
+    Consecutive collapsed nodes are stacked tightly (with minimal gap) to
+    keep related math/converter chains visually grouped together.
+    """
+    COLLAPSED_GAP = 4
+
+    x = 0.0
+    for column in columns:
+        col_width = 0.0
+        y = 0.0
+        prev_hidden = False
+
+        for node in column:
+            node.update()
+
+            width, height = calculate_node_dimensions(node, connection_counts, 1.0)
+
+            if width > col_width:
+                col_width = width
+
+            node.location = (x, y)
+
+            # use tight spacing between consecutive collapsed nodes
+            if node.hide and prev_hidden:
+                y -= height + COLLAPSED_GAP
+            else:
+                y -= height + spacing[1]
+
+            prev_hidden = node.hide
+
+        x += col_width + spacing[0]
+
+
+def position_reroutes(tree: bpy.types.NodeTree) -> None:
+    """Place reroute nodes midway between their source and target."""
+    for node in tree.nodes:
+        if node.bl_idname != "NodeReroute":
+            continue
+
+        sources: list[bpy.types.Node] = []
+        targets: list[bpy.types.Node] = []
+        for link in tree.links:
+            if link.to_node == node:
+                sources.append(link.from_node)
+            if link.from_node == node:
+                targets.append(link.to_node)
+
+        neighbours = sources + targets
+        if not neighbours:
+            continue
+
+        avg_x = sum(n.location.x for n in neighbours) / len(neighbours)
+        avg_y = sum(n.location.y for n in neighbours) / len(neighbours)
+        node.location = (avg_x, avg_y)
+
+
+def arrange_tree(
+    tree: bpy.types.NodeTree,
+    spacing: tuple[float, float] = (50, 25),
+) -> None:
+    """Arrange nodes in a node tree based on their dependencies.
+
+    Organises layoutable nodes into columns from left to right and positions
+    reroute nodes between their neighbours.  Frame nodes are left untouched.
+    """
+    if not tree.nodes:
+        return
+
+    dependency_graph, connection_counts = build_dependency_graph(tree)
+
+    if not dependency_graph:
+        return
+
+    nodes_in_order = topological_sort(dependency_graph)
+    columns = organize_into_columns(nodes_in_order, dependency_graph)
+    _reduce_crossings(columns, tree)
+    position_nodes_in_columns(columns, connection_counts, spacing)
+    position_reroutes(tree)

{nodebpy-0.7.2 → nodebpy-0.8.0}/src/nodebpy/builder.py

@@ -18,7 +18,7 @@ from bpy.types import (
     ShaderNodeTree,
 )
 
-from .lib.nodearrange import arrange
+from .arrange import arrange_tree
 from .types import (
     LINKABLE,
     SOCKET_COMPATIBILITY,
@@ -32,8 +32,6 @@ from .types import (
     _SocketShapeStructureType,
 )
 
-# from .arrange import arrange_tree
-
 GEO_NODE_NAMES = (
     f"GeometryNode{name}"
     for name in (
@@ -169,7 +167,7 @@ class TreeBuilder:
             "GeometryNodeTree", "ShaderNodeTree", "CompositorNodeTree"
         ] = "GeometryNodeTree",
         collapse: bool = False,
-        arrange: bool = True,
+        arrange: Literal["sugiyama", "simple"] | None = "sugiyama",
         fake_user: bool = False,
     ):
         if isinstance(tree, str):
@@ -191,7 +189,7 @@ class TreeBuilder:
         name: GeometryNodeTree | str = "Geometry Nodes",
         *,
         collapse: bool = False,
-        arrange: bool = True,
+        arrange: Literal["sugiyama", "simple"] | None = "sugiyama",
         fake_user: bool = False,
     ) -> "TreeBuilder":
         """Create a geometry node tree."""
@@ -209,7 +207,7 @@ class TreeBuilder:
         name: ShaderNodeTree | str = "Shader Nodes",
         *,
         collapse: bool = False,
-        arrange: bool = True,
+        arrange: Literal["sugiyama", "simple"] | None = "sugiyama",
         fake_user: bool = False,
     ) -> "TreeBuilder":
         """Create a shader node tree."""
@@ -227,7 +225,7 @@ class TreeBuilder:
         name: CompositorNodeTree | str = "Compositor Nodes",
         *,
         collapse: bool = False,
-        arrange: bool = True,
+        arrange: Literal["sugiyama", "simple"] | None = "sugiyama",
         fake_user: bool = False,
     ) -> "TreeBuilder":
         """Create a compositor node tree."""
@@ -264,7 +262,7 @@ class TreeBuilder:
         return self
 
     def __exit__(self, *args):
-        if self._arrange:
+        if self._arrange is not None:
             self.arrange()
         self._apply_input_defaults()
         self.deactivate_tree()
@@ -280,8 +278,25 @@ class TreeBuilder:
         return len(self.nodes)
 
     def arrange(self):
-        arrange.sugiyama.sugiyama_layout(self.tree)
-        arrange.sugiyama.config.reset()
+        if self._arrange == "sugiyama":
+            try:
+                from .lib.nodearrange import arrange as nodearrange
+
+                nodearrange.sugiyama.sugiyama_layout(self.tree)
+                nodearrange.sugiyama.config.reset()
+            except ImportError as e:
+                if "networkx" not in str(e):
+                    raise
+                import warnings
+
+                warnings.warn(
+                    "networkx is not installed, falling back to simple arrangement. "
+                    "Install networkx for the Sugiyama layout: pip install nodebpy[networkx]",
+                    stacklevel=2,
+                )
+                arrange_tree(self.tree)
+        elif self._arrange == "simple":
+            arrange_tree(self.tree)
 
     def _repr_markdown_(self) -> str | None:
         """

nodebpy-0.7.2/src/nodebpy/arrange.py

@@ -1,365 +0,0 @@
-import typing
-from collections import Counter, deque
-
-import bpy
-from mathutils import Vector
-
-
-def contains_geo_socket(sockets: bpy.types.NodeInputs | bpy.types.NodeOutputs) -> bool:
-    """
-    Check if any socket in the collection is a geometry socket
-
-    Parameters
-    ----------
-    sockets : bpy.types.NodeInputs | bpy.types.NodeOutputs
-        Collection of node sockets to check
-
-    Returns
-    -------
-    bool
-        True if any socket is a geometry socket
-    """
-    return any([s.bl_idname == "NodeSocketGeometry" for s in sockets])
-
-
-def node_has_geo_socket(node: bpy.types.GeometryNode) -> bool:
-    """
-    Check if a node has any geometry sockets in its inputs or outputs
-
-    Parameters
-    ----------
-    node : bpy.types.GeometryNode
-        The node to check
-
-    Returns
-    -------
-    bool
-        True if the node has at least one geometry socket
-    """
-    return any([contains_geo_socket(x) for x in [node.inputs, node.outputs]])
-
-
-def build_dependency_graph(tree: bpy.types.NodeTree) -> tuple[dict, Counter]:
-    """
-    Build a graph representing node dependencies and count input connections
-
-    Parameters
-    ----------
-    tree : bpy.types.NodeTree
-        The node tree to analyze
-
-    Returns
-    -------
-    tuple
-        Contains:
-            dict
-                Mapping of nodes to their dependent nodes
-            Counter
-                Count of connections for each socket
-    """
-    dependency_graph = {node: set() for node in tree.nodes}
-    socket_input_connection_count = Counter()
-
-    # populate the graph based on node connections
-    for link in tree.links:
-        dependency_graph[link.from_node].add(link.to_node)
-        socket_input_connection_count[link.to_socket] += 1
-
-    return dependency_graph, socket_input_connection_count
-
-
-def topological_sort(dependency_graph: dict) -> list:
-    """
-    Sort nodes by their dependencies using a topological sort algorithm
-
-    Parameters
-    ----------
-    dependency_graph : dict
-        Mapping of nodes to their dependent nodes
-
-    Returns
-    -------
-    list
-        Nodes sorted in topological order
-    """
-    # count incoming connections for each node
-    incoming_connection_count = {node: 0 for node in dependency_graph}
-    for source_node in dependency_graph:
-        for target_node in dependency_graph[source_node]:
-            incoming_connection_count[target_node] += 1
-
-    # start with nodes that have no dependencies
-    processing_queue = deque(
-        [
-            node
-            for node in incoming_connection_count
-            if incoming_connection_count[node] == 0
-        ]
-    )
-    sorted_node_order = []
-
-    # process nodes in breadth-first order
-    while processing_queue:
-        current_node = processing_queue.popleft()
-        sorted_node_order.append(current_node)
-
-        # update counts for nodes that depend on the current node
-        for dependent_node in dependency_graph[current_node]:
-            incoming_connection_count[dependent_node] -= 1
-            # if all dependencies are processed, add to queue
-            if incoming_connection_count[dependent_node] == 0:
-                processing_queue.append(dependent_node)
-
-    return sorted_node_order
-
-
-def organize_into_columns(nodes_in_order: list, dependency_graph: dict) -> list:
-    """
-    Organize nodes into columns based on their dependencies
-
-    Parameters
-    ----------
-    nodes_in_order : list
-        Nodes sorted in topological order
-    dependency_graph : dict
-        Mapping of nodes to their dependent nodes
-
-    Returns
-    -------
-    list
-        Columns of nodes, where each column is a list of nodes
-    """
-    node_columns = []
-    node_column_assignment = {}
-
-    for node in reversed(nodes_in_order):
-        # node goes in column after its furthest dependent
-        node_column_assignment[node] = (
-            max(
-                [
-                    node_column_assignment[dependent_node]
-                    for dependent_node in dependency_graph[node]
-                ],
-                default=-1,
-            )
-            + 1
-        )
-
-        # add node to its assigned column
-        if node_column_assignment[node] == len(node_columns):
-            node_columns.append([node])
-        else:
-            node_columns[node_column_assignment[node]].append(node)
-
-    # reverse columns to get left-to-right flow
-    return list(reversed(node_columns))
-
-
-def calculate_node_dimensions(
-    node: bpy.types.Node, socket_input_connection_count: Counter, interface_scale: float
-) -> tuple[float, float]:
-    """
-    Calculate the visual dimensions of a node
-
-    Parameters
-    ----------
-    node : bpy.types.Node
-        The node to calculate dimensions for
-    socket_input_connection_count : Counter
-        Counter of connections for each socket
-    interface_scale : float
-        UI scale factor
-
-    Returns
-    -------
-    tuple[float, float]
-        Width and height of the node
-    """
-    # height constants for different node elements
-    node_header_height = 20
-    node_socket_height = 28
-    node_property_row_height = 28
-    node_vector_input_height = 84
-
-    # count enabled inputs and outputs
-    enabled_input_count = len(
-        list(filter(lambda input_socket: input_socket.enabled, node.inputs))
-    )
-    enabled_output_count = len(
-        list(filter(lambda output_socket: output_socket.enabled, node.outputs))
-    )
-
-    # get properties specific to this node type (not inherited)
-    inherited_property_ids = [
-        property.identifier
-        for base_class in type(node).__bases__
-        for property in base_class.bl_rna.properties
-    ]
-
-    node_specific_property_count = len(
-        [
-            property
-            for property in node.bl_rna.properties
-            if property.identifier not in inherited_property_ids
-        ]
-    )
-
-    # count vector inputs that need UI widgets (not connected)
-    unconnected_vector_input_count = len(
-        list(
-            filter(
-                lambda input_socket: (
-                    input_socket.enabled
-                    and input_socket.type == "VECTOR"
-                    and socket_input_connection_count[input_socket] == 0
-                ),
-                node.inputs,
-            )
-        )
-    )
-
-    # calculate total node height based on components
-    total_node_height = (
-        node_header_height
-        + (enabled_output_count * node_socket_height)
-        + (node_specific_property_count * node_property_row_height)
-        + (enabled_input_count * node_socket_height)
-        + (unconnected_vector_input_count * node_vector_input_height)
-    ) * interface_scale
-
-    return node.width, total_node_height
-
-
-def position_nodes_in_columns(
-    node_columns: list,
-    socket_input_connection_count: Counter,
-    spacing: typing.Tuple[float, float] = (50, 25),
-) -> None:
-    """Position nodes in columns with appropriate spacing
-
-    Parameters
-    ----------
-    node_columns : list
-        List of columns, where each column is a list of nodes
-    socket_input_connection_count : Counter
-        Counter of connections for each socket
-    spacing : tuple of float, optional
-        Tuple of (horizontal, vertical) spacing between nodes, by default (50, 25)
-    """
-    interface_scale = 1.0
-    non_geo_offset = 20 + 28 * 2  # header + 2 socket heights
-
-    # position nodes column by column
-    position_x = 0
-    for column in node_columns:
-        widest_node_in_column = 0
-        position_y = 0
-
-        for node in column:
-            node.update()
-
-            width, height = calculate_node_dimensions(
-                node, socket_input_connection_count, interface_scale
-            )
-
-            # track widest node for column spacing
-            if width > widest_node_in_column:
-                widest_node_in_column = width
-
-            # position node
-            node.location = (position_x, position_y)
-
-            # adjust position for non-geometry nodes
-            if not node_has_geo_socket(node):
-                node.location -= Vector((0, non_geo_offset))
-
-            # move down for next node with spacing
-            position_y -= height + spacing[1]
-
-        # move right for next column with spacing
-        position_x += widest_node_in_column + spacing[0]
-
-
-def position_special_nodes(
-    tree: bpy.types.NodeTree, vertical_offset: float = 100
-) -> None:
-    """Position special nodes like Group Input and Group Output at the top
-
-    Parameters
-    ----------
-    tree : bpy.types.NodeTree
-        The node tree to modify
-    vertical_offset : float, optional
-        Vertical offset above the highest node, by default 100
-
-    Returns
-    -------
-    None
-    """
-    highest_y_position = max([node.location[1] for node in tree.nodes])
-    for special_node_name in ["Group Input", "Group Output"]:
-        if special_node_name in tree.nodes:
-            special_node = tree.nodes[special_node_name]
-            special_node.location = (
-                special_node.location[0],
-                highest_y_position + vertical_offset,
-            )
-
-
-def cleanup_orphaned_nodes(
-    tree: bpy.types.NodeTree, max_iter: int = 100, add_group_input: bool = True
-) -> None:
-    """Remove nodes that are not connected to anything"""
-    to_remove = []
-    for _ in range(max_iter):
-        for node in tree.nodes:
-            if len(node.outputs) == 0:
-                continue
-            if not any([s.is_linked for s in node.outputs]):
-                to_remove.append(node)
-
-        if len(to_remove) == 0:
-            break
-
-        for node in to_remove:
-            tree.nodes.remove(node)
-
-        to_remove = []
-
-    if add_group_input and "Group Input" not in tree.nodes:
-        n_input = tree.nodes.new("NodeGroupInput")
-        if "Join Geometry" in tree.nodes:
-            tree.links.new(n_input.outputs[0], tree.nodes["Join Geometry"].inputs[0])
-
-
-def arrange_tree(
-    tree: bpy.types.NodeTree,
-    spacing: typing.Tuple[float, float] = (50, 25),
-    add_group_input: bool = True,
-) -> None:
-    """Arrange nodes in a node tree based on their dependencies
-
-    Parameters
-    ----------
-    tree : bpy.types.GeometryNodeTree
-        The node tree to arrange
-    spacing : tuple of float
-        Tuple of (horizontal, vertical) spacing between nodes
-
-    Returns
-    -------
-    None
-        This function modifies the node tree in place
-
-    Notes
-    -----
-    This function organizes nodes into columns and positions them with appropriate spacing.
-    Nodes are arranged from left to right based on their dependencies, with special
-    handling for geometry nodes and group input/output nodes.
-    """
-    cleanup_orphaned_nodes(tree, add_group_input=add_group_input)
-    dependency_graph, socket_input_connection_count = build_dependency_graph(tree)
-    nodes_in_dependency_order = topological_sort(dependency_graph)
-    node_columns = organize_into_columns(nodes_in_dependency_order, dependency_graph)
-    position_nodes_in_columns(node_columns, socket_input_connection_count, spacing)
-    position_special_nodes(tree)