nodebpy 0.18.0__tar.gz → 520.0.1__tar.gz

{nodebpy-0.18.0 → nodebpy-520.0.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.18.0
+Version: 520.0.1
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
 License: GPL-3.0-or-later
-Requires-Dist: bpy>=5.1.0 ; extra == 'bpy'
+Requires-Dist: bpy==5.2.* ; extra == 'bpy'
 Requires-Dist: networkx>=3.6.1 ; extra == 'networkx'
 Requires-Python: >=3.13
 Provides-Extra: bpy

{nodebpy-0.18.0 → nodebpy-520.0.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "0.18.0"
+version = "520.0.1"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
@@ -17,7 +17,7 @@ networkx = [
     "networkx>=3.6.1",
 ]
 bpy = [
-    "bpy>=5.1.0",
+    "bpy==5.2.*",
 ]
 
 [build-system]
@@ -36,7 +36,6 @@ dev = [
     "quartodoc>=0.11.1",
     "ruff>=0.14.11",
     "syrupy>=5.0.0",
-    "tree-clipper>=0.1.1",
     "pytest-xdist>=3.8.0",
     "griffe<2.0.0",
     "ty>=0.0.35",

{nodebpy-0.18.0 → nodebpy-520.0.1}/src/nodebpy/builder/__init__.py

@@ -11,24 +11,49 @@ from .node import (
 )
 from .socket import (
     BooleanSocket,
+    BooleanSocketGrid,
+    BooleanSocketList,
     BundleSocket,
+    BundleSocketList,
     ClosureSocket,
+    ClosureSocketList,
     CollectionSocket,
+    CollectionSocketList,
     ColorSocket,
+    ColorSocketList,
     FloatSocket,
+    FloatSocketGrid,
+    FloatSocketList,
     FontSocket,
+    FontSocketList,
     GeometrySocket,
+    GeometrySocketList,
     ImageSocket,
+    ImageSocketList,
     IntegerSocket,
+    IntegerSocketGrid,
+    IntegerSocketList,
+    IntegerVectorSocket,
     MaterialSocket,
+    MaterialSocketList,
     MatrixSocket,
+    MatrixSocketList,
     MenuSocket,
+    MenuSocketList,
     ObjectSocket,
+    ObjectSocketList,
     RotationSocket,
+    RotationSocketList,
     ShaderSocket,
+    ShaderSocketList,
     Socket,
+    SoundSocket,
+    SoundSocketList,
     StringSocket,
+    StringSocketList,
     VectorSocket,
+    VectorSocketGrid,
+    VectorSocketList,
 )
 from .tree import (
     InputInterfaceContext,
@@ -55,25 +80,51 @@ __all__ = [
     "CustomCompositorGroup",
     "CustomGeometryGroup",
     "CustomShaderGroup",
+    "CustomShaderGroup",
     # Runtime socket types
     "FloatSocket",
+    "FloatSocketGrid",
+    "FloatSocketList",
     "VectorSocket",
+    "VectorSocketGrid",
+    "VectorSocketList",
     "ColorSocket",
+    "ColorSocketList",
     "IntegerSocket",
+    "IntegerVectorSocket",
+    "IntegerSocketGrid",
+    "IntegerSocketList",
     "BooleanSocket",
+    "BooleanSocketGrid",
+    "BooleanSocketList",
     "RotationSocket",
+    "RotationSocketList",
     "MatrixSocket",
+    "MatrixSocketList",
     "StringSocket",
+    "StringSocketList",
     "MenuSocket",
+    "MenuSocketList",
     "GeometrySocket",
+    "GeometrySocketList",
     "ObjectSocket",
+    "ObjectSocketList",
     "FontSocket",
+    "FontSocketList",
     "MaterialSocket",
+    "MaterialSocketList",
     "ImageSocket",
+    "ImageSocketList",
     "CollectionSocket",
+    "CollectionSocketList",
     "BundleSocket",
+    "BundleSocketList",
     "ClosureSocket",
+    "ClosureSocketList",
     "ShaderSocket",
+    "ShaderSocketList",
+    "SoundSocket",
+    "SoundSocketList",
     # Tree context
     "SocketContext",
     "PanelContext",

nodebpy-520.0.1/src/nodebpy/builder/_registry.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from bpy.types import NodeSocket
+
+if TYPE_CHECKING:
+    from .socket import Socket
+
+_SOCKET_REGISTRY: dict[str, "type[Socket]"] = {}
+_SOCKET_LIST_REGISTRY: dict[str, "type[Socket]"] = {}
+_SOCKET_GRID_REGISTRY: dict[str, "type[Socket]"] = {}
+
+
+def _wrap_socket(socket: NodeSocket) -> "Socket":
+    for key, cls in _SOCKET_REGISTRY.items():
+        if key in socket.bl_idname:
+            structure = getattr(socket, "inferred_structure_type", "SINGLE")
+            if structure == "LIST":
+                return _SOCKET_LIST_REGISTRY.get(key, cls)(socket)
+            elif structure == "GRID":
+                return _SOCKET_GRID_REGISTRY.get(key, cls)(socket)
+            return cls(socket)
+    from .socket import Socket
+
+    return Socket(socket)

{nodebpy-0.18.0 → nodebpy-520.0.1}/src/nodebpy/builder/_utils.py

@@ -47,6 +47,7 @@ def _allow_innactive_sockets(node: bpy.types.Node) -> bool:
         "GeometryNodeIndexSwitch",
         "GeometryNodeMenuSwitch",
         "ShaderNodeMixShader",
+        # "ShaderNodeMix",
         "GeometryNodeSwitch",
     )
 

{nodebpy-0.18.0 → nodebpy-520.0.1}/src/nodebpy/builder/accessor.py

@@ -5,7 +5,7 @@ from typing import TYPE_CHECKING, Iterator, Literal, overload
 import bpy
 from bpy.types import NodeSocket
 
-from ._registry import _get_socket_linker
+from ._registry import _wrap_socket
 from ._utils import (
     SocketError,
     _allow_innactive_sockets,
@@ -79,14 +79,14 @@ class SocketAccessor:
         """Get a Socket for a socket by identifier, name, or index."""
         if isinstance(key, slice):
             sockets = [
-                _get_socket_linker(self._collection[i])
+                _wrap_socket(self._collection[i])
                 for i in range(*key.indices(len(self._collection)))
             ]
             if self._builder is not None:
                 for s in sockets:
                     s._builder_node = self._builder
             return sockets
-        socket = _get_socket_linker(self._collection[self._index(key)])
+        socket = _wrap_socket(self._collection[self._index(key)])
         if self._builder is not None:
             socket._builder_node = self._builder
         return socket
@@ -185,7 +185,7 @@ class SocketAccessor:
         Uses node-level visibility rules regardless of ``ignore_visibility`` —
         see ``_visible_sockets`` for rationale.
         """
-        return [_get_socket_linker(s) for s in self._visible_sockets()]
+        return [_wrap_socket(s) for s in self._visible_sockets()]
 
     def _items(self) -> "list[tuple[str, Socket]]":
         """All visible sockets as (name, Socket) pairs.
@@ -193,7 +193,7 @@ class SocketAccessor:
         Uses node-level visibility rules regardless of ``ignore_visibility`` —
         see ``_visible_sockets`` for rationale.
         """
-        return [(s.name, _get_socket_linker(s)) for s in self._visible_sockets()]
+        return [(s.name, _wrap_socket(s)) for s in self._visible_sockets()]
 
     def _keys(self) -> list[str]:
         """All visible socket names."""

{nodebpy-0.18.0 → nodebpy-520.0.1}/src/nodebpy/builder/mixins.py

@@ -1,16 +1,17 @@
 from __future__ import annotations
 
 from types import EllipsisType
-from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
+from typing import TYPE_CHECKING, Any, Self, TypeVar, cast, overload
 
 from bpy.types import NodeLink, NodeSocket
 
-from ._registry import _get_socket_linker
+from ._registry import _wrap_socket
 from ._utils import SocketError, _resolve_promotion, _SocketLike
 
 _RShiftT = TypeVar("_RShiftT")
 
 if TYPE_CHECKING:
+    from ..nodes.geometry import CombineTransform
     from ..types import InputLinkable
     from .accessor import SocketAccessor
     from .node import BaseNode
@@ -19,6 +20,7 @@ if TYPE_CHECKING:
         FloatSocket,
         IntegerSocket,
         MatrixSocket,
+        Position,
         Socket,
         VectorSocket,
     )
@@ -30,7 +32,7 @@ class OperatorMixin:
 
     Requires ``_default_output_socket`` on the concrete class.
     Delegates all dispatch to type-specific ``_dispatch_*`` methods on Socket
-    subclasses, looked up via ``_get_socket_linker``.
+    subclasses, looked up via ``_wrap_socket``.
     """
 
     __array_ufunc__ = None
@@ -48,7 +50,7 @@ class OperatorMixin:
             other,
             reverse,
         )
-        return _get_socket_linker(socket)._dispatch_math(other, operation, reverse)
+        return _wrap_socket(socket)._dispatch_math(other, operation, reverse)
 
     def __mul__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "multiply")
@@ -92,7 +94,7 @@ class OperatorMixin:
             other,
             False,
         )
-        return _get_socket_linker(socket)._dispatch_floordiv(other, reverse)
+        return _wrap_socket(socket)._dispatch_floordiv(other, reverse)
 
     def __rfloordiv__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         socket, other, reverse = _resolve_promotion(
@@ -100,15 +102,66 @@ class OperatorMixin:
             other,
             True,
         )
-        return _get_socket_linker(socket)._dispatch_floordiv(other, reverse)
+        return _wrap_socket(socket)._dispatch_floordiv(other, reverse)
+
+    @overload
+    def __matmul__(self, other: "Position") -> "VectorSocket": ...
+    @overload
+    def __matmul__(self, other: "CombineTransform") -> "VectorSocket": ...
+    def __matmul__(
+        self, other: "Position | CombineTransform | VectorSocket | MatrixSocket"
+    ) -> "VectorSocket | MatrixSocket":
+        from ..builder.socket import VectorSocket
+        from ..nodes.geometry import (
+            MultiplyMatrices,
+            Position,
+            TransformPoint,
+        )
+
+        if isinstance(other, (Position, VectorSocket)):
+            return TransformPoint(other, self).o.vector  # ty: ignore[invalid-argument-type]
+
+        return MultiplyMatrices(self, other).o.matrix  # ty: ignore[invalid-argument-type]
+
+    def __rmatmul__(self, other: Any) -> "MatrixSocket | VectorSocket":
+        from ..builder.socket import VectorSocket
+        from ..nodes.geometry import MultiplyMatrices, Position, TransformPoint
+
+        if isinstance(
+            self,
+            (
+                VectorSocket,
+                Position,
+            ),
+        ):
+            return TransformPoint(self, other).o.vector
+
+        return MultiplyMatrices(other, self).o.matrix  # ty: ignore[invalid-argument-type]
 
     def __neg__(self) -> "FloatSocket | VectorSocket | IntegerSocket":
-        return _get_socket_linker(self._default_output_socket)._dispatch_unary("negate")
+        return _wrap_socket(self._default_output_socket)._dispatch_unary("negate")
 
     def __abs__(self) -> "FloatSocket | VectorSocket | IntegerSocket":
-        return _get_socket_linker(self._default_output_socket)._dispatch_unary(
-            "absolute"
-        )
+        return _wrap_socket(self._default_output_socket)._dispatch_unary("absolute")
+
+    if TYPE_CHECKING:
+
+        def __mul__(self, other: Any) -> Self: ...
+        def __rmul__(self, other: Any) -> Self: ...
+        def __truediv__(self, other: Any) -> Self: ...
+        def __rtruediv__(self, other: Any) -> Self: ...
+        def __add__(self, other: Any) -> Self: ...
+        def __radd__(self, other: Any) -> Self: ...
+        def __sub__(self, other: Any) -> Self: ...
+        def __rsub__(self, other: Any) -> Self: ...
+        def __pow__(self, other: Any) -> Self: ...
+        def __rpow__(self, other: Any) -> Self: ...
+        def __mod__(self, other: Any) -> Self: ...
+        def __rmod__(self, other: Any) -> Self: ...
+        def __floordiv__(self, other: Any) -> Self: ...
+        def __rfloordiv__(self, other: Any) -> Self: ...
+        def __neg__(self) -> Self: ...
+        def __abs__(self) -> Self: ...
 
     def _apply_compare_operation(
         self, other: Any, operation: str
@@ -118,7 +171,7 @@ class OperatorMixin:
             other,
             False,
         )
-        return _get_socket_linker(socket)._dispatch_compare(other, operation)
+        return _wrap_socket(socket)._dispatch_compare(other, operation)
 
     def __lt__(self, other: Any) -> "FloatSocket | BooleanSocket":
         return self._apply_compare_operation(other, "less_than")
@@ -172,41 +225,6 @@ class OperatorMixin:
 
         return BooleanMath.l_not(cast(Any, self))
 
-    @staticmethod
-    def _cast_to_matrix(value) -> MatrixSocket:
-        from ..nodes.geometry.converter import CombineMatrix
-
-        if hasattr(value, "shape") and value.shape == (4, 4):
-            return CombineMatrix(*value.ravel()).o.matrix
-        else:
-            return value
-
-    def __matmul__(self, other: Any) -> "MatrixSocket | VectorSocket":
-        from ..nodes.geometry.converter import MultiplyMatrices, TransformPoint
-
-        other = self._cast_to_matrix(other)
-        socket = self._default_output_socket
-
-        if socket.type == "MATRIX" and other.type == "VECTOR":
-            return TransformPoint(other, socket).o.vector
-
-        return MultiplyMatrices(socket, other).o.matrix
-
-    @overload
-    def __rmatmul__(self, other: MatrixSocket) -> "MatrixSocket": ...
-    @overload
-    def __rmatmul__(self, other: VectorSocket) -> "VectorSocket": ...
-    def __rmatmul__(self, other: Any) -> "MatrixSocket | VectorSocket":
-        from ..nodes.geometry.converter import MultiplyMatrices, TransformPoint
-
-        other = self._cast_to_matrix(other)
-        socket = self._default_output_socket
-
-        if socket.type == "VECTOR" and getattr(other, "type", None) == "MATRIX":
-            return TransformPoint(socket, other).o.vector
-
-        return MultiplyMatrices(other, socket).o.matrix
-
 
 class LinkingMixin:
     """Node/socket linking logic: ``>>``, ``_link``, best-socket matching.
@@ -332,11 +350,10 @@ class LinkingMixin:
         source: "InputLinkable",
         input: "InputLinkable | str",
     ):
+        from .node import _find_socket_from_name
+
         if isinstance(input, str):
-            try:
-                self._link(source, self.node.inputs[input])
-            except KeyError:
-                self._link(source, self.node.inputs[self.i._index(input)])
+            self._link(source, _find_socket_from_name(self.node.inputs, input))
         else:
             self._link(source, input)
 

{nodebpy-0.18.0 → nodebpy-520.0.1}/src/nodebpy/builder/node.py

@@ -45,6 +45,25 @@ if TYPE_CHECKING:
         def i(self) -> SocketAccessor: ...
 
 
+def _find_socket_from_name(
+    collection: bpy.types.NodeInputs | bpy.types.NodeOutputs | list[NodeSocket],
+    name: str,
+) -> NodeSocket:
+    ids = [socket.identifier for socket in collection]
+    names = [socket.name for socket in collection]
+    for format in [name, name.title(), name.replace("_", " ").title()]:
+        try:
+            return collection[names.index(format)]
+        except ValueError:
+            try:
+                return collection[ids.index(format)]
+            except ValueError:
+                continue
+    raise ValueError(
+        f"Socket '{name}' not found in collection names or ids, available names: {names}, available ids: {ids}"
+    )
+
+
 class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
     """Base class for all node wrappers."""
 
@@ -143,8 +162,8 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
             input.default_value = value  # type: ignore
 
     def _establish_links(self, **kwargs: InputAny):
-        input_ids = [input.identifier for input in self.node.inputs]
         for name, value in kwargs.items():
+            # TODO: don't like these manual overrides for particular nodes, but best I can do for now
             if value is None or (
                 "GridPrune" in self._bl_idname
                 and name == "Threshold"
@@ -167,15 +186,13 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
             elif isinstance(value, _NodeLike):
                 self._link_from(value.o._best_match(self.i._get(name).type), name)  # type: ignore
             else:
-                if name in input_ids:
-                    input = self.node.inputs[input_ids.index(name)]
-                    self._set_input_default_value(input, value)
-                else:
-                    if name in self.node.inputs:
-                        input = self.node.inputs[name]
-                    else:
-                        input = self.node.inputs[name.replace("_", " ").title()]
-                    self._set_input_default_value(input, value)
+                # TODO: explicitly skipping the sockets for BooleanMath as they are default false,
+                # but this needs to be a more generic solution for sockets which aren't available
+                # https://github.com/BradyAJohnston/nodebpy/issues/90
+                if "BooleanMath" in self._bl_idname and value is False:
+                    continue
+                socket = _find_socket_from_name(self.node.inputs, name)
+                self._set_input_default_value(socket, value)
 
     @property
     def o(self) -> SocketAccessor: