nodebpy 520.32.0__tar.gz → 520.32.1__tar.gz

{nodebpy-520.32.0 → nodebpy-520.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.32.0
+Version: 520.32.1
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>

{nodebpy-520.32.0 → nodebpy-520.32.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.32.0"
+version = "520.32.1"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [

{nodebpy-520.32.0 → nodebpy-520.32.1}/src/nodebpy/builder/items.py

@@ -184,6 +184,8 @@ def _resolve_source(
     """The source socket, its socket type and the item name for a linkable.
 
     The name is the source socket's unless one is given."""
+    if isinstance(value, Item):
+        value = value.output
     accessor = getattr(value, "o", None)
     if accessor is None and not isinstance(value, (NodeSocket, _SocketLike)):
         raise TypeError(f"{value!r} is not a socket, node or default value")
@@ -199,6 +201,7 @@ def _resolve_source(
 
 _InT = TypeVar("_InT", bound=BaseSocket, default=Socket)
 _OutT = TypeVar("_OutT", bound=BaseSocket, default=_InT)
+_RShiftT = TypeVar("_RShiftT")
 
 
 class Item(Generic[_InT, _OutT]):
@@ -209,9 +212,14 @@ class Item(Generic[_InT, _OutT]):
     from. The type parameters are the socket classes of the two roles; one
     parameter means both roles share it, none means plain :class:`Socket`.
 
-    Linking into ``input`` with ``>>`` continues the chain from ``output``::
+    The handle stands in for its sockets: as a value or on the left of
+    ``>>`` it is ``output``, on the right of ``>>`` it is ``input``, and the
+    chain then continues from ``output``::
 
-        g.Position() >> capture.items.vector().input >> g.SetPosition()
+        g.Position() >> capture.items.vector() >> g.SetPosition()
+        g.SetPosition(position=capture.items.vector(g.Position()))
+
+    An item with only one side raises for the side it does not have.
 
     Holds the item's collection index rather than the bpy item itself:
     bpy collection item references are invalidated when the collection
@@ -260,6 +268,19 @@ class Item(Generic[_InT, _OutT]):
             "_OutT", _wrap_socket(self._items._item_socket(self._item, output=True))
         )
 
+    # -- the handle as a link source or target --
+
+    @property
+    def _default_output_socket(self) -> NodeSocket:
+        return self.output.socket
+
+    def _as_rshift_target(self) -> _InT:
+        return self.input
+
+    def __rshift__(self, other: _RShiftT) -> _RShiftT:
+        """``item >> target`` links from the item's output socket."""
+        return cast("_RShiftT", self.output >> cast(Any, other))
+
 
 def _chained(socket: NodeSocket, continues: bool, follow) -> Socket:
     """Wrap a link-target socket so ``>>`` into it carries on from the

{nodebpy-520.32.0 → nodebpy-520.32.1}/src/nodebpy/builder/mixins.py

@@ -10,14 +10,17 @@ from ._registry import _wrap_socket
 from ._utils import SocketError, _resolve_promotion, _SocketLike
 
 _RShiftT = TypeVar("_RShiftT")
+_OutT = TypeVar("_OutT", bound="BaseSocket")
 
 if TYPE_CHECKING:
     from ..nodes.geometry import CombineTransform
     from ..nodes.geometry.converter import BooleanMath
     from ..types import InputLinkable
     from .accessor import SocketAccessor
+    from .items import Item
     from .node import BaseNode
     from .socket import (
+        BaseSocket,
         BooleanSocket,
         FloatSocket,
         MatrixSocket,
@@ -367,6 +370,8 @@ class LinkingMixin:
     @overload
     def __rshift__(self, other: None) -> Self: ...
     @overload
+    def __rshift__(self, other: Item[Any, _OutT]) -> _OutT: ...
+    @overload
     def __rshift__(self, other: _RShiftT) -> _RShiftT: ...
     def __rshift__(self, other: _RShiftT | None) -> _RShiftT | Self:
         """Chain nodes using >> operator. Links output to input.
@@ -387,6 +392,10 @@ class LinkingMixin:
         """
         if other is None:
             return self
+        as_target = getattr(other, "_as_rshift_target", None)
+        if as_target is not None:
+            # an item handle stands for its input socket on the right of >>
+            return self >> as_target()
         if isinstance(other, _SocketLike):
             source = self._default_output_socket
             target = other.socket

{nodebpy-520.32.0 → nodebpy-520.32.1}/src/nodebpy/builder/node.py

@@ -238,6 +238,10 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
         elif isinstance(value, _NodeLike):
             target_type = target.type if not named else self.i._get(target).type
             self._link_from(value.o._best_match(target_type), target)
+        elif getattr(value, "_as_rshift_target", None) is not None:
+            # an item handle stands for its output socket (and says so when
+            # it has none)
+            self._link_from(cast(Any, value)._default_output_socket, target)
         else:
             # 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

{nodebpy-520.32.0 → nodebpy-520.32.1}/src/nodebpy/nodes/geometry/zone.py

@@ -1,6 +1,6 @@
 from abc import ABC
 from collections.abc import Iterable, Iterator, Mapping
-from typing import TYPE_CHECKING, ClassVar, TypeVar, cast
+from typing import TYPE_CHECKING, ClassVar, NoReturn, TypeVar, cast
 
 import bpy
 from bpy.types import (
@@ -152,6 +152,24 @@ class ZoneItem(Item[_SocketT]):
         """Output-node output socket — read the item after the zone."""
         return self.output
 
+    # A state item has two inputs and two outputs, so the handle itself
+    # cannot stand for a socket: name the role.
+    def _no_role(self, side: str) -> NoReturn:
+        raise TypeError(
+            f"{self!r} has two {side} sockets; link through .initial / .current / "
+            ".next / .result rather than the handle"
+        )
+
+    @property
+    def _default_output_socket(self) -> bpy.types.NodeSocket:
+        self._no_role("output")
+
+    def _as_rshift_target(self) -> _SocketT:
+        self._no_role("input")
+
+    def __rshift__(self, other: object) -> NoReturn:
+        self._no_role("output")
+
 
 class _ZonePair:
     """Zone wrapper holding the paired input and output builder nodes.