nodebpy 0.16.0__tar.gz → 0.18.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.16.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.16.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.16.0 → nodebpy-0.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "0.16.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.16.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.16.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.16.0 → nodebpy-0.18.0}/src/nodebpy/builder/accessor.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Literal, overload
+from typing import TYPE_CHECKING, Iterator, Literal, overload
 
 import bpy
 from bpy.types import NodeSocket
@@ -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
 
@@ -200,7 +202,7 @@ class SocketAccessor:
     def __len__(self) -> int:
         return len(self._items())
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator["Socket"]:
         return iter(self._values())
 
     def __getattr__(self, name: str) -> "Socket":

{nodebpy-0.16.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, Math, MultiplyMatrices, TransformPoint
     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.16.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)]