nodebpy 0.4.1__tar.gz → 0.5.0__tar.gz

{nodebpy-0.4.1 → nodebpy-0.5.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.4.1
-Summary: Build nodes in Blender with code
+Version: 0.5.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.0 ; extra == 'bpy'
+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: pytest>=9.0.2 ; extra == 'dev'
@@ -165,5 +165,5 @@ Most node classes are generated automatically with this. The nodes in
 complexities of particular nodes (usually lergacy).
 
 ``` bash
-uv run generate.py && ruff format && ruff check --fix --unsafe-fixes
+uv run generate.py && ruff format && ruff check --fix
 ```

{nodebpy-0.4.1 → nodebpy-0.5.0}/README.md

@@ -141,5 +141,5 @@ Most node classes are generated automatically with this. The nodes in
 complexities of particular nodes (usually lergacy).
 
 ``` bash
-uv run generate.py && ruff format && ruff check --fix --unsafe-fixes
+uv run generate.py && ruff format && ruff check --fix
 ```

{nodebpy-0.4.1 → nodebpy-0.5.0}/pyproject.toml

@@ -1,7 +1,7 @@
 [project]
 name = "nodebpy"
-version = "0.4.1"
-description = "Build nodes in Blender with code"
+version = "0.5.0"
+description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
     { name = "Brady Johnston", email = "brady.johnston@me.com" }
@@ -16,7 +16,7 @@ nodebpy = "nodebpy:main"
 
 [project.optional-dependencies]
 bpy = [
-    "bpy>=5.0.0",
+    "bpy>=5.0.1",
 ]
 jupyter = [
     "ipython>=8.0.0",
@@ -36,3 +36,8 @@ dev = [
 [build-system]
 requires = ["uv_build>=0.8.15,<0.9.0"]
 build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "numpy<2.0",
+]

{nodebpy-0.4.1 → nodebpy-0.5.0}/src/nodebpy/__init__.py

@@ -1,9 +1,13 @@
-from . import nodes, sockets, screenshot
+from . import nodes, screenshot, sockets
 from .builder import TreeBuilder
+from .nodes import compositor, geometry, shader
 from .screenshot import generate_mermaid_diagram, save_mermaid_diagram
 
 __all__ = [
     "nodes",
+    "compositor",
+    "geometry",
+    "shader",
     "sockets",
     "screenshot",
     "TreeBuilder",

{nodebpy-0.4.1 → nodebpy-0.5.0}/src/nodebpy/arrange.py

@@ -1,5 +1,6 @@
 import typing
 from collections import Counter, deque
+
 import bpy
 from mathutils import Vector
 
@@ -245,7 +246,7 @@ def position_nodes_in_columns(
     spacing : tuple of float, optional
         Tuple of (horizontal, vertical) spacing between nodes, by default (50, 25)
     """
-    interface_scale = bpy.context.preferences.view.ui_scale
+    interface_scale = 1.0
     non_geo_offset = 20 + 28 * 2  # header + 2 socket heights
 
     # position nodes column by column

{nodebpy-0.4.1 → nodebpy-0.5.0}/src/nodebpy/builder.py

@@ -3,14 +3,19 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Any, ClassVar, Iterable, Literal
 
 if TYPE_CHECKING:
-    from .nodes import Math, VectorMath
+    from .nodes.geometry import IntegerMath, Math, VectorMath
+    from .nodes.geometry.converter import BooleanMath, MultiplyMatrices
+    from .nodes.geometry.manual import Compare
 
 import bpy
 from bpy.types import (
+    CompositorNodeTree,
     GeometryNodeTree,
     Node,
     Nodes,
     NodeSocket,
+    NodeTree,
+    ShaderNodeTree,
 )
 
 from .lib.nodearrange import arrange
@@ -64,9 +69,9 @@ class SocketContext:
         self.builder = tree_builder
 
     @property
-    def tree(self) -> GeometryNodeTree:
+    def tree(self) -> NodeTree:
         tree = self.builder.tree
-        assert tree is not None and isinstance(tree, GeometryNodeTree)
+        assert tree is not None
         return tree
 
     @property
@@ -114,7 +119,10 @@ class OutputInterfaceContext(DirectionalContext):
 
 
 class TreeBuilder:
-    """Builder for creating Blender geometry node trees with a clean Python API."""
+    """Builder for creating Blender node trees with a clean Python API.
+
+    Supports geometry, shader, and compositor node trees.
+    """
 
     _tree_contexts: ClassVar["list[TreeBuilder]"] = []
     just_added: "Node | None" = None
@@ -122,15 +130,18 @@ class TreeBuilder:
 
     def __init__(
         self,
-        tree: GeometryNodeTree | str = "Geometry Nodes",
+        tree: NodeTree | str = "Geometry Nodes",
         *,
+        tree_type: Literal[
+            "GeometryNodeTree", "ShaderNodeTree", "CompositorNodeTree"
+        ] = "GeometryNodeTree",
         collapse: bool = False,
         arrange: bool = True,
+        fake_user: bool = False,
     ):
         if isinstance(tree, str):
-            self.tree = bpy.data.node_groups.new(tree, "GeometryNodeTree")
+            self.tree = bpy.data.node_groups.new(tree, tree_type)
         else:
-            assert isinstance(tree, GeometryNodeTree)
             self.tree = tree
 
         # Create socket accessors for named access
@@ -138,11 +149,74 @@ class TreeBuilder:
         self.outputs = OutputInterfaceContext(self)
         self._arrange = arrange
         self.collapse = collapse
+        self.fake_user = fake_user
+
+    @classmethod
+    def geometry(
+        cls,
+        name: GeometryNodeTree | str = "Geometry Nodes",
+        *,
+        collapse: bool = False,
+        arrange: bool = True,
+        fake_user: bool = False,
+    ) -> "TreeBuilder":
+        """Create a geometry node tree."""
+        return cls(
+            name,
+            tree_type="GeometryNodeTree",
+            collapse=collapse,
+            arrange=arrange,
+            fake_user=fake_user,
+        )
+
+    @classmethod
+    def shader(
+        cls,
+        name: ShaderNodeTree | str = "Shader Nodes",
+        *,
+        collapse: bool = False,
+        arrange: bool = True,
+        fake_user: bool = False,
+    ) -> "TreeBuilder":
+        """Create a shader node tree."""
+        return cls(
+            name,
+            tree_type="ShaderNodeTree",
+            collapse=collapse,
+            arrange=arrange,
+            fake_user=fake_user,
+        )
+
+    @classmethod
+    def compositor(
+        cls,
+        name: CompositorNodeTree | str = "Compositor Nodes",
+        *,
+        collapse: bool = False,
+        arrange: bool = True,
+        fake_user: bool = False,
+    ) -> "TreeBuilder":
+        """Create a compositor node tree."""
+        return cls(
+            name,
+            tree_type="CompositorNodeTree",
+            collapse=collapse,
+            arrange=arrange,
+            fake_user=fake_user,
+        )
 
     @property
     def nodes(self) -> Nodes:
         return self.tree.nodes
 
+    @property
+    def fake_user(self) -> bool:
+        return self.tree.use_fake_user
+
+    @fake_user.setter
+    def fake_user(self, value: bool) -> None:
+        self.tree.use_extra_user = value
+
     def activate_tree(self) -> None:
         """Make this tree the active tree for all new node creation."""
         TreeBuilder._tree_contexts.append(self)
@@ -247,6 +321,7 @@ class NodeBuilder:
     _from_socket: NodeSocket | None = None
     _default_input_id: str | None = None
     _default_output_id: str | None = None
+    __array_ufunc__ = None
 
     def __init__(self):
         # Get active tree from context manager
@@ -458,7 +533,13 @@ class NodeBuilder:
     def _establish_links(self, **kwargs: TYPE_INPUT_ALL):
         input_ids = [input.identifier for input in self.node.inputs]
         for name, value in kwargs.items():
-            if value is None:
+            if value is None or (
+                # TODO: this is an ugly single-node exception for this particular case. I'd
+                # like to fine a cleaner way to handle this automatically instead.
+                "GridPrune" in self._bl_idname
+                and name == "Threshold"
+                and self.node.data_type == "BOOLEAN"
+            ):
                 continue
             if isinstance(value, Node):
                 node = NodeBuilder()
@@ -522,7 +603,7 @@ class NodeBuilder:
         self, other: Any, operation: str, reverse: bool = False
     ) -> "VectorMath | Math":
         """Apply a math operation with appropriate Math/VectorMath node."""
-        from .nodes import VectorMath
+        from .nodes.geometry import VectorMath
 
         values = (
             (self._default_output_socket, other)
@@ -556,9 +637,9 @@ class NodeBuilder:
                 if isinstance(other, (int, float)):
                     scalar_vector = (other, other, other)
                     return (
-                        vector_method(scalar_vector, self._default_output_socket)
+                        vector_method(self._default_output_socket, scalar_vector)
                         if not reverse
-                        else vector_method(self._default_output_socket, scalar_vector)
+                        else vector_method(scalar_vector, self._default_output_socket)
                     )
                 elif (
                     isinstance(other, (list, tuple)) and len(other) == 3
@@ -570,12 +651,16 @@ class NodeBuilder:
                         f"Unsupported type for {operation} with VECTOR operand: {type(other)}"
                     )
         else:  # Both operands are scalar types, use regular Math
-            from .nodes.converter import IntegerMath, Math
+            from .nodes.geometry.converter import IntegerMath, Math
 
             if isinstance(other, int) and self._default_output_socket.type == "INT":
                 return getattr(IntegerMath, operation)(*values)
             else:
-                return getattr(Math, operation)(*values)
+                # Math node uses 'floored_modulo' instead of 'modulo'
+                math_operation = (
+                    "floored_modulo" if operation == "modulo" else operation
+                )
+                return getattr(Math, math_operation)(*values)
 
     def __mul__(self, other: Any) -> "VectorMath | Math":
         return self._apply_math_operation(other, "multiply")
@@ -601,6 +686,179 @@ class NodeBuilder:
     def __rsub__(self, other: Any) -> "VectorMath | Math":
         return self._apply_math_operation(other, "subtract", reverse=True)
 
+    def __pow__(self, other: Any) -> "VectorMath | Math":
+        return self._apply_math_operation(other, "power")
+
+    def __rpow__(self, other: Any) -> "VectorMath | Math":
+        return self._apply_math_operation(other, "power", reverse=True)
+
+    def __mod__(self, other: Any) -> "VectorMath | Math":
+        return self._apply_math_operation(other, "modulo")
+
+    def __rmod__(self, other: Any) -> "VectorMath | Math":
+        return self._apply_math_operation(other, "modulo", reverse=True)
+
+    def __floordiv__(self, other: Any) -> "VectorMath | Math | IntegerMath":
+        return self._apply_floordiv_operation(other)
+
+    def __rfloordiv__(self, other: Any) -> "VectorMath | Math | IntegerMath":
+        return self._apply_floordiv_operation(other, reverse=True)
+
+    def __neg__(self) -> "VectorMath | Math | IntegerMath":
+        from .nodes.geometry import VectorMath
+        from .nodes.geometry.converter import IntegerMath, Math
+
+        socket = self._default_output_socket
+        if socket.type == "VECTOR":
+            return VectorMath.scale(socket, -1)
+        elif socket.type == "INT":
+            return IntegerMath.negate(socket)
+        else:
+            return Math.multiply(socket, -1)
+
+    def __abs__(self) -> "VectorMath | Math | IntegerMath":
+        from .nodes.geometry import VectorMath
+        from .nodes.geometry.converter import IntegerMath, Math
+
+        socket = self._default_output_socket
+        if socket.type == "VECTOR":
+            return VectorMath.absolute(socket)
+        elif socket.type == "INT":
+            return IntegerMath.absolute(socket)
+        else:
+            return Math.absolute(socket)
+
+    def _apply_floordiv_operation(
+        self, other: Any, reverse: bool = False
+    ) -> "VectorMath | Math | IntegerMath":
+        """Apply floor division: divide then floor."""
+        from .nodes.geometry import VectorMath
+        from .nodes.geometry.converter import IntegerMath, Math
+
+        socket = self._default_output_socket
+        component_is_vector = (
+            socket.type == "VECTOR" or getattr(other, "type", None) == "VECTOR"
+        )
+
+        if not component_is_vector and isinstance(other, int) and socket.type == "INT":
+            values = (socket, other) if not reverse else (other, socket)
+            return IntegerMath.divide_floor(*values)
+
+        divided = self._apply_math_operation(other, "divide", reverse=reverse)
+        if component_is_vector:
+            return VectorMath.floor(divided)
+        else:
+            return Math.floor(divided)
+
+    def _apply_compare_operation(self, other: Any, operation: str) -> "Compare | Math":
+        """Apply a comparison operation.
+
+        Uses the Compare node in geometry trees (supports float, int, vector and
+        outputs a boolean). Falls back to Math.less_than / Math.greater_than in
+        compositor and shader trees which lack a Compare node. For <= and >= in
+        non-geometry trees, we swap the operands (a <= b == b >= a == !(a > b)
+        is equivalent to less_than(b, a) when treating the output as boolean).
+        """
+        if isinstance(self._tree.tree, GeometryNodeTree):
+            from .nodes.geometry.manual import Compare
+
+            socket = self._default_output_socket
+            values = (socket, other)
+
+            if socket.type == "VECTOR":
+                return getattr(Compare, operation).vector(*values)
+            elif socket.type == "INT":
+                return getattr(Compare, operation).integer(*values)
+            else:
+                return getattr(Compare, operation).float(*values)
+        else:
+            # Compositor / Shader trees only have Math.less_than and
+            # Math.greater_than (float output, no boolean). Map <= and >= by
+            # swapping operands: a <= b ≡ less_than(b, a) is wrong —
+            # but greater_than(b, a) gives 1 when b>a i.e. a<b.
+            # So: a <= b → 1 - greater_than(a, b)  — needs two nodes.
+            # Simpler: a >= b ≡ !(a < b) ≡ 1 - less_than(a, b)
+            from .nodes.geometry.converter import Math
+
+            socket = self._default_output_socket
+            _MATH_COMPARE_MAP = {
+                "less_than": ("less_than", False),
+                "greater_than": ("greater_than", False),
+                "less_equal": ("greater_than", True),  # a<=b → !(a>b) → 1-gt(a,b)
+                "greater_equal": ("less_than", True),  # a>=b → !(a<b) → 1-lt(a,b)
+            }
+            math_op, negate = _MATH_COMPARE_MAP[operation]
+            result = getattr(Math, math_op)(socket, other)
+            if negate:
+                result = Math.subtract(1.0, result._default_output_socket)
+            return result
+
+    def __lt__(self, other: Any) -> "Compare":
+        return self._apply_compare_operation(other, "less_than")
+
+    def __gt__(self, other: Any) -> "Compare":
+        return self._apply_compare_operation(other, "greater_than")
+
+    def __le__(self, other: Any) -> "Compare":
+        return self._apply_compare_operation(other, "less_equal")
+
+    def __ge__(self, other: Any) -> "Compare":
+        return self._apply_compare_operation(other, "greater_equal")
+
+    def _apply_boolean_operation(self, other: Any, operation: str) -> "BooleanMath":
+        """Apply a boolean operation using the BooleanMath node."""
+        from .nodes.geometry.converter import BooleanMath
+
+        return getattr(BooleanMath, operation)(self, other)
+
+    def __and__(self, other: Any) -> "BooleanMath":
+        return self._apply_boolean_operation(other, "l_and")
+
+    def __rand__(self, other: Any) -> "BooleanMath":
+        from .nodes.geometry.converter import BooleanMath
+
+        return BooleanMath.l_and(other, self)
+
+    def __or__(self, other: Any) -> "BooleanMath":
+        return self._apply_boolean_operation(other, "l_or")
+
+    def __ror__(self, other: Any) -> "BooleanMath":
+        from .nodes.geometry.converter import BooleanMath
+
+        return BooleanMath.l_or(other, self)
+
+    def __xor__(self, other: Any) -> "BooleanMath":
+        return self._apply_boolean_operation(other, "not_equal")
+
+    def __rxor__(self, other: Any) -> "BooleanMath":
+        from .nodes.geometry.converter import BooleanMath
+
+        return BooleanMath.not_equal(other, self)
+
+    def __invert__(self) -> "BooleanMath":
+        from .nodes.geometry.converter import BooleanMath
+
+        return BooleanMath.l_not(self)
+
+    @staticmethod
+    def _cast_to_matrix(value):
+        from .nodes.geometry.converter import CombineMatrix
+
+        if hasattr(value, "shape") and value.shape == (4, 4):
+            return CombineMatrix(*value.ravel())
+        else:
+            return value
+
+    def __matmul__(self, other: Any) -> "MultiplyMatrices":
+        from .nodes.geometry.converter import MultiplyMatrices
+
+        return MultiplyMatrices(self, self._cast_to_matrix(other))
+
+    def __rmatmul__(self, other: Any) -> "MultiplyMatrices":
+        from .nodes.geometry.converter import MultiplyMatrices
+
+        return MultiplyMatrices(self._cast_to_matrix(other), self)
+
 
 class DynamicInputsMixin:
     _socket_data_types: tuple[str]
@@ -1213,3 +1471,26 @@ class SocketClosure(SocketBase):
             hide_value=hide_value,
             hide_in_modifier=hide_in_modifier,
         )
+
+
+class SocketShader(SocketBase):
+    """Shader that is the final output for a material"""
+
+    _bl_socket_type: str = "NodeSocketShader"
+    socket: bpy.types.NodeTreeInterfaceSocketShader
+
+    def __init__(
+        self,
+        name: str = "Shader",
+        description: str = "",
+        *,
+        optional_label: bool = False,
+        hide_value: bool = False,
+        hide_in_modifier: bool = False,
+    ):
+        super().__init__(name, description)
+        self._set_values(
+            optional_label=optional_label,
+            hide_value=hide_value,
+            hide_in_modifier=hide_in_modifier,
+        )

{nodebpy-0.4.1 → nodebpy-0.5.0}/src/nodebpy/lib/nodearrange/arrange/graph.py

@@ -482,7 +482,7 @@ class ClusterGraph:
 def get_socket_y(socket: NodeSocket) -> float:
     b_socket = bNodeSocket.from_address(socket.as_pointer())
     ui_scale = 1.0  # type: ignore
-    return b_socket.runtime.contents.location[1] / ui_scale
+    return 1.0
 
 
 @dataclass(frozen=True)

nodebpy-0.5.0/src/nodebpy/nodes/__init__.py

@@ -0,0 +1,3 @@
+from . import compositor, geometry, shader
+
+__all__ = ["compositor", "geometry", "shader"]