nodebpy 0.17.0__tar.gz → 0.18.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.17.0
+Version: 0.18.0
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
@@ -130,7 +130,7 @@ Some nodes are manually specified in the `src/nodebpy/nodes/geometry/manual.py`
 Run the build & format script as such:
 
 ```bash
-uv run generate.py && uvx ruff format && uvx ruff check --fix
+uv run generate.py && uvx ruff format && uvx ruff check --fix && uvx ty check --fix src
 ```
 
 ## Other Projects

{nodebpy-0.17.0 → nodebpy-0.18.0}/README.md

@@ -116,7 +116,7 @@ Some nodes are manually specified in the `src/nodebpy/nodes/geometry/manual.py`
 Run the build & format script as such:
 
 ```bash
-uv run generate.py && uvx ruff format && uvx ruff check --fix
+uv run generate.py && uvx ruff format && uvx ruff check --fix && uvx ty check --fix src
 ```
 
 ## Other Projects

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

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "0.17.0"
+version = "0.18.0"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
@@ -28,7 +28,7 @@ build-backend = "uv_build"
 dev = [
     "ipython>=8.0.0",
     "networkx>=3.6.1",
-    "fake-bpy-module>=20260113",
+    "fake-bpy-module>=20260501",
     "jsondiff>=2.2.1",
     "pytest>=9.0.2",
     "pytest-cov>=7.0.0",
@@ -38,5 +38,6 @@ dev = [
     "syrupy>=5.0.0",
     "tree-clipper>=0.1.1",
     "pytest-xdist>=3.8.0",
-    "griffe<2.0.0"
+    "griffe<2.0.0",
+    "ty>=0.0.35",
 ]

{nodebpy-0.17.0 → nodebpy-0.18.0}/src/nodebpy/arrange.py

@@ -117,7 +117,7 @@ def calculate_node_dimensions(
     inherited_ids = {
         prop.identifier
         for base in type(node).__bases__
-        for prop in base.bl_rna.properties
+        for prop in getattr(base, "bl_rna").properties
     }
     node_property_count = sum(
         1 for prop in node.bl_rna.properties if prop.identifier not in inherited_ids
@@ -143,6 +143,7 @@ def calculate_node_dimensions(
 
 def _socket_index(socket: bpy.types.NodeSocket) -> int:
     """Return the index of a socket among its node's enabled sockets."""
+    assert socket.node is not None
     collection = socket.node.inputs if not socket.is_output else socket.node.outputs
     idx = 0
     for s in collection:
@@ -208,6 +209,7 @@ def _reduce_crossings(
         # 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))
+        assert link.from_socket is not None and link.to_socket is not None
         src_frac = _socket_index(link.from_socket) / out_count
         dst_frac = _socket_index(link.to_socket) / in_count
 
@@ -299,8 +301,10 @@ def position_reroutes(tree: bpy.types.NodeTree) -> None:
         targets: list[bpy.types.Node] = []
         for link in tree.links:
             if link.to_node == node:
+                assert link.from_node is not None
                 sources.append(link.from_node)
             if link.from_node == node:
+                assert link.to_node is not None
                 targets.append(link.to_node)
 
         neighbours = sources + targets

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

@@ -63,7 +63,7 @@ def _resolve_promotion(
     """
     other_type = getattr(other, "type", None)
     self_prec = _TYPE_PRECEDENCE.get(self_socket.type, 1)
-    other_prec = _TYPE_PRECEDENCE.get(other_type, -1)  # type: ignore[arg-type]
+    other_prec = _TYPE_PRECEDENCE.get(other_type, -1) if other_type is not None else -1
 
     if other_prec > self_prec:
         # Other side is dominant — swap so the linker wraps the vector/higher socket

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

@@ -103,10 +103,12 @@ class SocketAccessor:
     def _node(self) -> bpy.types.Node:
         """The node this accessor is associated with."""
         if isinstance(self._collection, list):
+            assert self._collection[0].node is not None
             return self._collection[0].node
         # bpy NodeInputs/NodeOutputs.id_data returns the NodeTree (top-level ID),
         # not the Node. Retrieve the node via the first socket instead.
         for s in self._collection:
+            assert s.node is not None
             return s.node
         return self._collection.data  # empty collection fallback
 

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

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from types import EllipsisType
-from typing import TYPE_CHECKING, Any, TypeVar, overload
+from typing import TYPE_CHECKING, Any, TypeVar, cast, overload
 
 from bpy.types import NodeLink, NodeSocket
 
@@ -11,8 +11,8 @@ from ._utils import SocketError, _resolve_promotion, _SocketLike
 _RShiftT = TypeVar("_RShiftT")
 
 if TYPE_CHECKING:
-    from ..nodes.geometry import Compare
     from ..types import InputLinkable
+    from .accessor import SocketAccessor
     from .node import BaseNode
     from .socket import (
         BooleanSocket,
@@ -35,75 +35,78 @@ class OperatorMixin:
 
     __array_ufunc__ = None
 
+    if TYPE_CHECKING:
+
+        @property
+        def _default_output_socket(self) -> "NodeSocket": ...
+
     def _apply_math_operation(
         self, other: Any, operation: str, reverse: bool = False
     ) -> "FloatSocket | VectorSocket | IntegerSocket":
         socket, other, reverse = _resolve_promotion(
             self._default_output_socket,
             other,
-            reverse,  # type: ignore[attr-defined]
+            reverse,
         )
         return _get_socket_linker(socket)._dispatch_math(other, operation, reverse)
 
-    def __mul__(self, other: Any) -> "FloatSocket":
+    def __mul__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "multiply")
 
-    def __rmul__(self, other: Any) -> "FloatSocket":
+    def __rmul__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "multiply", reverse=True)
 
-    def __truediv__(self, other: Any) -> "FloatSocket":
+    def __truediv__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "divide")
 
-    def __rtruediv__(self, other: Any) -> "FloatSocket":
+    def __rtruediv__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "divide", reverse=True)
 
-    def __add__(self, other: Any) -> "FloatSocket":
+    def __add__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "add")
 
-    def __radd__(self, other: Any) -> "FloatSocket":
+    def __radd__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "add", reverse=True)
 
-    def __sub__(self, other: Any) -> "FloatSocket":
+    def __sub__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "subtract")
 
-    def __rsub__(self, other: Any) -> "FloatSocket":
+    def __rsub__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "subtract", reverse=True)
 
-    def __pow__(self, other: Any) -> "FloatSocket":
+    def __pow__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "power")
 
-    def __rpow__(self, other: Any) -> "FloatSocket":
+    def __rpow__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "power", reverse=True)
 
-    def __mod__(self, other: Any) -> "FloatSocket":
+    def __mod__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "modulo")
 
-    def __rmod__(self, other: Any) -> "FloatSocket":
+    def __rmod__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         return self._apply_math_operation(other, "modulo", reverse=True)
 
-    def __floordiv__(self, other: Any) -> "FloatSocket":
+    def __floordiv__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         socket, other, reverse = _resolve_promotion(
             self._default_output_socket,
             other,
-            False,  # type: ignore[attr-defined]
+            False,
         )
         return _get_socket_linker(socket)._dispatch_floordiv(other, reverse)
 
-    def __rfloordiv__(self, other: Any) -> "FloatSocket":
+    def __rfloordiv__(self, other: Any) -> "FloatSocket | VectorSocket | IntegerSocket":
         socket, other, reverse = _resolve_promotion(
             self._default_output_socket,
             other,
-            True,  # type: ignore[attr-defined]
+            True,
         )
         return _get_socket_linker(socket)._dispatch_floordiv(other, reverse)
 
-    def __neg__(self) -> "FloatSocket":
-        return _get_socket_linker(self._default_output_socket)._dispatch_unary(  # type: ignore[attr-defined]
-            "negate"
-        )
+    def __neg__(self) -> "FloatSocket | VectorSocket | IntegerSocket":
+        return _get_socket_linker(self._default_output_socket)._dispatch_unary("negate")
 
-    def __abs__(self) -> "FloatSocket":
-        return _get_socket_linker(self._default_output_socket)._dispatch_unary(  # type: ignore[attr-defined]
+    def __abs__(self) -> "FloatSocket | VectorSocket | IntegerSocket":
+        return _get_socket_linker(self._default_output_socket)._dispatch_unary(
             "absolute"
         )
 
@@ -111,28 +114,28 @@ class OperatorMixin:
         self, other: Any, operation: str
     ) -> "FloatSocket | BooleanSocket":
         socket, other, _ = _resolve_promotion(
-            self._default_output_socket,  # type: ignore[attr-defined]
+            self._default_output_socket,
             other,
             False,
         )
         return _get_socket_linker(socket)._dispatch_compare(other, operation)
 
-    def __lt__(self, other: Any) -> "BooleanSocket":
+    def __lt__(self, other: Any) -> "FloatSocket | BooleanSocket":
         return self._apply_compare_operation(other, "less_than")
 
-    def __gt__(self, other: Any) -> "Compare":
+    def __gt__(self, other: Any) -> "FloatSocket | BooleanSocket":
         return self._apply_compare_operation(other, "greater_than")
 
-    def __le__(self, other: Any) -> "Compare":
+    def __le__(self, other: Any) -> "FloatSocket | BooleanSocket":
         return self._apply_compare_operation(other, "less_equal")
 
-    def __ge__(self, other: Any) -> "Compare":
+    def __ge__(self, other: Any) -> "FloatSocket | BooleanSocket":
         return self._apply_compare_operation(other, "greater_equal")
 
-    def __eq__(self, other: Any) -> "Compare":  # type: ignore[override]
+    def __eq__(self, other: Any) -> "FloatSocket | BooleanSocket":  # type: ignore
         return self._apply_compare_operation(other, "equal")
 
-    def __ne__(self, other: Any) -> "Compare":  # type: ignore[override]
+    def __ne__(self, other: Any) -> "FloatSocket | BooleanSocket":  # type: ignore
         return self._apply_compare_operation(other, "not_equal")
 
     def _apply_boolean_operation(self, other: Any, operation: str):
@@ -146,7 +149,7 @@ class OperatorMixin:
     def __rand__(self, other: Any):
         from ..nodes.geometry.converter import BooleanMath
 
-        return BooleanMath.l_and(other, self)
+        return BooleanMath.l_and(other, cast(Any, self))
 
     def __or__(self, other: Any):
         return self._apply_boolean_operation(other, "l_or")
@@ -154,7 +157,7 @@ class OperatorMixin:
     def __ror__(self, other: Any):
         from ..nodes.geometry.converter import BooleanMath
 
-        return BooleanMath.l_or(other, self)
+        return BooleanMath.l_or(other, cast(Any, self))
 
     def __xor__(self, other: Any):
         return self._apply_boolean_operation(other, "not_equal")
@@ -162,12 +165,12 @@ class OperatorMixin:
     def __rxor__(self, other: Any):
         from ..nodes.geometry.converter import BooleanMath
 
-        return BooleanMath.not_equal(other, self)
+        return BooleanMath.not_equal(other, cast(Any, self))
 
     def __invert__(self):
         from ..nodes.geometry.converter import BooleanMath
 
-        return BooleanMath.l_not(self)
+        return BooleanMath.l_not(cast(Any, self))
 
     @staticmethod
     def _cast_to_matrix(value) -> MatrixSocket:
@@ -214,6 +217,20 @@ class LinkingMixin:
 
     tree: "TreeBuilder"
 
+    if TYPE_CHECKING:
+        import bpy
+
+        node: bpy.types.Node
+
+        @property
+        def i(self) -> "SocketAccessor": ...
+
+        @property
+        def o(self) -> "SocketAccessor": ...
+
+        @property
+        def _default_output_socket(self) -> "NodeSocket": ...
+
     def _source_socket(self, node: "InputLinkable | Socket | NodeSocket") -> NodeSocket:
         assert node is not None
         if isinstance(node, NodeSocket):
@@ -254,8 +271,12 @@ class LinkingMixin:
 
         if isinstance(target, BaseNode):
             inputs = target.i._available
-        else:
+        elif isinstance(target, Socket):
+            inputs = [target.socket]
+        elif isinstance(target, NodeSocket):
             inputs = [target]
+        else:
+            raise TypeError(f"Cannot get inputs from {type(target)}")
 
         # NodeReroute adapts its type to whatever is linked — skip type matching
         if getattr(getattr(target, "node", None), "bl_idname", None) == "NodeReroute":
@@ -291,8 +312,10 @@ class LinkingMixin:
         if possible_combos:
             return sorted(possible_combos, key=lambda x: x[0])[0][1]
 
+        src_name = getattr(getattr(source, "node", None), "name", repr(source))
+        tgt_name = getattr(getattr(target, "node", None), "name", repr(target))
         raise SocketError(
-            f"Cannot link any output from {source.node.name} to any input of {target.node.name}. "  # type: ignore[union-attr]
+            f"Cannot link any output from {src_name} to any input of {tgt_name}. "
             f"Available output types: {[f'{o.name}:{o.type}' for o in outputs]}, "
             f"Available input types: {[f'{i.name}:{i.type}' for i in inputs]}"
         )
@@ -333,17 +356,24 @@ class LinkingMixin:
             source = self._default_output_socket
             target = other.socket
         elif getattr(other, "_placeholder_inputs", None):
-            name = other._placeholder_inputs.pop(0)
+            node_other = cast("BaseNode", other)
+            name = node_other._placeholder_inputs.pop(0)
             try:
-                target = other.node.inputs[name]
+                target = node_other.node.inputs[name]
             except KeyError:
-                target = other.node.inputs[other.i._index(name)]
-            source = self.o._best_match(target.type) if hasattr(self, "o") else self
+                target = node_other.node.inputs[node_other.i._index(name)]
+            source = (
+                self.o._best_match(target.type)
+                if hasattr(self, "o")
+                else self._default_output_socket
+            )
         else:
             try:
-                source, target = self._find_best_socket_pair(self, other)
+                source, target = self._find_best_socket_pair(self, cast(Any, other))
             except SocketError:
-                source, target = other._find_best_socket_pair(self, other)
+                source, target = cast("LinkingMixin", other)._find_best_socket_pair(
+                    self, cast(Any, other)
+                )
 
         self.tree.link(source, target)
         return other

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

@@ -138,9 +138,9 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
             and input.type == "VECTOR"
             and isinstance(value, (int, float))
         ):
-            input.default_value = [value] * len(input.default_value)
+            input.default_value = [value] * len(input.default_value)  # type: ignore
         else:
-            input.default_value = value
+            input.default_value = value  # type: ignore
 
     def _establish_links(self, **kwargs: InputAny):
         input_ids = [input.identifier for input in self.node.inputs]
@@ -165,7 +165,7 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
             elif isinstance(value, NodeSocket):
                 self._link_from(value, name)
             elif isinstance(value, _NodeLike):
-                self._link_from(value.o._best_match(self.i._get(name).type), name)
+                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)]

{nodebpy-0.17.0 → nodebpy-0.18.0}/src/nodebpy/builder/socket.py

@@ -68,11 +68,7 @@ from .mixins import LinkingMixin, OperatorMixin
 
 if TYPE_CHECKING:
     from ..nodes import compositor, geometry, shader
-    from ..nodes.geometry import (
-        IntegerMath,
-        MatchString,
-        Math,
-    )
+    from ..nodes.geometry import IntegerMath, MatchString, Math, ObjectInfo
     from ..nodes.geometry.manual import Compare
     from ..nodes.geometry.vector import VectorMath
     from .node import BaseNode
@@ -269,8 +265,8 @@ class Socket(BaseSocket, _SocketLike, OperatorMixin, LinkingMixin):
         def __gt__(self, other: Any) -> "BooleanSocket": ...
         def __le__(self, other: Any) -> "BooleanSocket": ...
         def __ge__(self, other: Any) -> "BooleanSocket": ...
-        def __eq__(self, other: Any) -> "Compare": ...
-        def __ne__(self, other: Any) -> "Compare": ...
+        def __eq__(self, other: Any) -> "BooleanSocket": ...
+        def __ne__(self, other: Any) -> "BooleanSocket": ...
 
 
 # ---------------------------------------------------------------------------
@@ -1553,13 +1549,10 @@ class _MatrixMixin(BaseSocket):
     if TYPE_CHECKING:
 
         @overload
-        def __matmul__(
-            self, other: "VectorSocket | NodeSocketVector"
-        ) -> "VectorSocket": ...
+        def __matmul__(self, other: "VectorSocket") -> "VectorSocket": ...
         @overload
-        def __matmul__(self, other: Any) -> "MatrixSocket": ...
-
-        def __rmatmul__(self, other: Any) -> "MatrixSocket": ...
+        def __matmul__(self, other: "MatrixSocket") -> "MatrixSocket": ...
+        def __rmatmul__(self, other: "MatrixSocket") -> "MatrixSocket": ...
 
 
 # ---------------------------------------------------------------------------
@@ -1621,6 +1614,21 @@ class GeometrySocket(Socket):
 
     socket: NodeSocketGeometry
 
+    def realize_instances(
+        self,
+        selection: InputBoolean = True,
+        realize_all: InputBoolean = False,
+        depth: InputInteger = 0,
+    ) -> "GeometrySocket":
+        from ..nodes.geometry import RealizeInstances
+
+        return RealizeInstances(
+            self.socket,
+            selection=selection,
+            realize_all=realize_all,
+            depth=depth,
+        ).o.geometry
+
 
 class ObjectSocket(Socket):
     """Runtime object socket wrapper."""
@@ -1635,6 +1643,110 @@ class ObjectSocket(Socket):
     def default_value(self, value: bpy.types.Object) -> None:
         self.socket.default_value = value
 
+    @property
+    def _info(self) -> "type[ObjectInfo]":
+        from ..nodes.geometry import ObjectInfo
+
+        return ObjectInfo
+
+    def transform(
+        self, transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL"
+    ) -> "MatrixSocket":
+        """The Object's transform matrix, optionally in relative space.
+
+        Adds [`ObjectInfo`](~nodebpy.nodes.geometry.ObjectInfo) to the node tree and returns.
+
+        Parameters
+        ----------
+        transform_space : Literal["ORIGINAL", "RELATIVE"]
+            The space in which to return the transform matrix.
+
+        Returns
+        -------
+        MatrixSocket
+            The output 'Transform' `MatrixSocket`.
+        """
+        return self._info(self.socket, transform_space=transform_space).o.transform
+
+    def location(
+        self, transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL"
+    ) -> "VectorSocket":
+        """
+        The object's location, optionally in relative space, via [`ObjectInfo`](~nodebpy.nodes.geometry.ObjectInfo).
+
+        Parameters
+        ----------
+        transform_space : Literal["ORIGINAL", "RELATIVE"]
+            The space in which to return the location.
+
+        Returns
+        -------
+        VectorSocket
+            The output 'Location' `VectorSocket`.
+
+        """
+        return self._info(self.socket, transform_space=transform_space).o.location
+
+    def rotation(
+        self, transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL"
+    ) -> "RotationSocket":
+        """
+        The object's rotation, optionally in relative space, via [`ObjectInfo`](~nodebpy.nodes.geometry.ObjectInfo).
+
+        Parameters
+        ----------
+        transform_space : Literal["ORIGINAL", "RELATIVE"]
+            The space in which to return the rotation.
+
+        Returns
+        -------
+        RotationSocket
+            The output 'Rotation' `RotationSocket`.
+        """
+        return self._info(self.socket, transform_space=transform_space).o.rotation
+
+    def scale(
+        self, transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL"
+    ) -> "VectorSocket":
+        """
+        The object's scale, optionally in relative space, via [`ObjectInfo`](~nodebpy.nodes.geometry.ObjectInfo).
+
+        Parameters
+        ----------
+        transform_space : Literal["ORIGINAL", "RELATIVE"]
+            The space in which to return the scale.
+
+        Returns
+        -------
+        VectorSocket
+            The output 'Scale' `VectorSocket`.
+        """
+        return self._info(self.socket, transform_space=transform_space).o.scale
+
+    def geometry(
+        self,
+        transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL",
+        as_instance: InputBoolean = False,
+    ) -> "GeometrySocket":
+        """
+        The object's geometry, optionally in relative space, via [`ObjectInfo`](~nodebpy.nodes.geometry.ObjectInfo).
+
+        Parameters
+        ----------
+        transform_space : Literal["ORIGINAL", "RELATIVE"]
+            The space in which to return the geometry.
+        as_instance : InputBoolean
+            Whether to return the geometry as an instance.
+
+        Returns
+        -------
+        GeometrySocket
+            The output 'Geometry' `GeometrySocket`.
+        """
+        return self._info(
+            self.socket, as_instance=as_instance, transform_space=transform_space
+        ).o.geometry
+
 
 class MaterialSocket(Socket):
     """Runtime material socket wrapper."""
@@ -1677,6 +1789,38 @@ class CollectionSocket(Socket):
     def default_value(self, value: bpy.types.Collection) -> None:
         self.socket.default_value = value
 
+    def instances(
+        self,
+        transform_space: Literal["ORIGINAL", "RELATIVE"] = "ORIGINAL",
+        separate_children: InputBoolean = False,
+        reset_children: InputBoolean = False,
+    ) -> "GeometrySocket":
+        """Import objects from the collection as instances.
+
+        Parameters
+        ----------
+        transform_space : Literal["ORIGINAL", "RELATIVE"]
+            The transform space to use for the instances.
+        separate_children : bool
+            Whether to separate objects as their own instances.
+        reset_children : bool
+            Whether to reset children of the collection to world origin.
+
+        Returns
+        -------
+        GeometrySocket
+            The output 'Instances' `GeometrySocket`. Will be a single instance or multiple instances if `separate_children` is `True`.
+
+        """
+        from ..nodes.geometry import CollectionInfo
+
+        return CollectionInfo(
+            self.socket,
+            separate_children,
+            reset_children,
+            transform_space=transform_space,
+        ).o.instances
+
 
 class BundleSocket(Socket):
     """Runtime bundle socket wrapper."""

{nodebpy-0.17.0 → nodebpy-0.18.0}/src/nodebpy/builder/tree.py

@@ -559,11 +559,13 @@ class SocketContext:
         return self._wrap(ShaderSocket, iface)
 
     def __len__(self) -> int:
+        assert self.tree.interface is not None
         return len(
             list(
                 item
                 for item in self.tree.interface.items_tree
-                if item.in_out == self._direction
+                if isinstance(item, bpy.types.NodeTreeInterfaceSocket)
+                and item.in_out == self._direction
             )
         )
 
@@ -610,7 +612,7 @@ class TreeBuilder(Generic[_TreeT]):
         if isinstance(tree, str):
             self.tree = bpy.data.node_groups.new(tree, tree_type)  # type: ignore[assignment]
         else:
-            self.tree = tree  # type: ignore[assignment]
+            self.tree = tree  # type: ignore
 
         self._menu_defaults: dict[str, str] = {}
         self.inputs = InputInterfaceContext(self)
@@ -720,7 +722,7 @@ class TreeBuilder(Generic[_TreeT]):
                     continue
                 if item.identifier == key:
                     if hasattr(item, "default_value"):
-                        item.default_value = value
+                        item.default_value = value  # type: ignore
 
     def __len__(self) -> int:
         return len(self.nodes)
@@ -728,10 +730,10 @@ class TreeBuilder(Generic[_TreeT]):
     def arrange(self):
         if self._arrange == "sugiyama":
             try:
-                from ..lib.nodearrange import arrange as nodearrange
+                from ..lib.nodearrange.arrange import sugiyama
 
-                nodearrange.sugiyama.sugiyama_layout(self.tree)
-                nodearrange.sugiyama.config.reset()
+                sugiyama.sugiyama_layout(self.tree)
+                sugiyama.config.reset()
             except ImportError as e:
                 if "networkx" not in str(e):
                     raise
@@ -805,8 +807,9 @@ class TreeBuilder(Generic[_TreeT]):
             assert socket1.node
             assert socket2.node
             for socket in [socket1, socket2]:
+                assert socket.node is not None
                 if socket.is_inactive and not _allow_innactive_sockets(socket.node):
-                    message = f"Socket {socket.name} from node {socket.node.name} is inactive."  # type: ignore
+                    message = f"Socket {socket.name} from node {socket.node.name} is inactive."
                     message += f" It is linked to socket {socket2.name} from node {socket2.node.name}."
                     message += " This link will be created by Blender but ignored when evaluated."
                     message += f"Socket type: {socket.bl_idname}"