nodebpy 520.32.0__tar.gz → 520.33.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.32.0
+Version: 520.33.0
 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.33.0}/pyproject.toml

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

{nodebpy-520.32.0 → nodebpy-520.33.0}/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.33.0}/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.33.0}/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.33.0}/src/nodebpy/builder/socket.py

@@ -1553,12 +1553,12 @@ class _FloatMixin[IntegerResult: (IntegerSocket, IntegerSocketGrid, IntegerSocke
 
         return Clamp.min_max(self.socket, min, max).o.result  # ty: ignore[invalid-return-type]
 
-    def min(self, value: InputFloat = 0.0) -> Self:
+    def min(self, value: InputFloat) -> Self:
         """Create Math with operation 'Minimum'. The minimum from self and value"""
         self._assert_output("min")
         return self._math.minimum(self.socket, value).o.value  # ty: ignore[invalid-return-type]
 
-    def max(self, value: InputFloat = 1.0) -> Self:
+    def max(self, value: InputFloat) -> Self:
         """Create Math with operation 'Maximum'. The maximum from self and value"""
         self._assert_output("max")
         return self._math.maximum(self.socket, value).o.value  # ty: ignore[invalid-return-type]
@@ -1727,11 +1727,19 @@ class _IntegerMixin[FloatResult: (FloatSocket, FloatSocketGrid, FloatSocketList)
         return IntegerMath
 
     def clamp(self, min: InputInteger = 0, max: InputInteger = 1) -> Self:
-        """Clamp the value to *[min, max]*."""
+        """Clamp the value to *[min, max]*. There isn't a built-in node for this, so it uses .max().min()"""
         self._assert_output("clamp")
-        return self._imath.minimum(
-            self._imath.maximum(self.socket, min).o.value, max
-        ).o.value  # ty: ignore[invalid-return-type]
+        return self.max(min).min(max)
+
+    def min(self, value: InputInteger) -> Self:
+        """Create IntegerMath with operation 'Minimum'. The minimum from self and value"""
+        self._assert_output("min")
+        return self._imath.minimum(self.socket, value).o.value  # ty: ignore[invalid-return-type]
+
+    def max(self, value: InputInteger) -> Self:
+        """Create IntegerMath with operation 'Maximum'. The maximum from self and value"""
+        self._assert_output("max")
+        return self._imath.maximum(self.socket, value).o.value  # ty: ignore[invalid-return-type]
 
     def modulo(self, divisor: InputInteger) -> Self:
         """Remainder after dividing by *divisor* (always non-negative)."""

{nodebpy-520.32.0 → nodebpy-520.33.0}/src/nodebpy/export/codegen.py

@@ -2316,14 +2316,16 @@ _SOCKET_METHODS: dict[str, list[SocketMethodSpec]] = {
             ("RADIANS", "to_radians"),
             ("DEGREES", "to_degrees"),
             ("SIGN", "sign"),
-            ("MINIMUM", "min", "value_001"),
-            ("MAXIMUM", "max", "value_001"),
             ("MULTIPLY_ADD", "mul_add", "multiplier", "addend"),
             ("PINGPONG", "ping_pong", "value"),
             ("LOGARITHM", "log", "base"),
             ("ARCTAN2", "atan2", "value"),
         ]
     ]
+    + [
+        _math_unary_spec(op, method, "value", always_args=1)
+        for op, method in (("MINIMUM", "min"), ("MAXIMUM", "max"))
+    ]
     # No float modulo lift: the float mixin's modulo() builds FLOORED_MODULO,
     # which the % operator lift already covers, and plain MODULO has no
     # faithful method equivalent so it stays a factory call.
@@ -2348,7 +2350,14 @@ _SOCKET_METHODS: dict[str, list[SocketMethodSpec]] = {
             ("MULTIPLY_ADD", "mul_add", "multiplier", "addend"),
         )
     ]
-    + [_int_math_unary_spec("MODULO", "modulo", "divisor", always_args=1)],
+    + [
+        _int_math_unary_spec(op, method, *args, always_args=1)
+        for op, method, *args in (
+            ("MODULO", "modulo", "divisor"),
+            ("MINIMUM", "min", "value"),
+            ("MAXIMUM", "max", "value"),
+        )
+    ],
     "GeometryNodeListLength": [
         _list_spec("list_length", "Length", type_prop="data_type"),
     ],

{nodebpy-520.32.0 → nodebpy-520.33.0}/src/nodebpy/nodes/geometry/groups.py

@@ -70,7 +70,7 @@ class SliceToIndices(CustomGeometryGroup):
 
         range = stop - start
         length = IntegerMath.divide_ceiling(range, step).o.value.abs()
-        indices = FieldToList(length).integer((start + step) * Index())
+        indices = FieldToList(length).items.integer((start + step) * Index())
 
         indices >> tree.outputs.integer("Indices", structure_type="LIST")
 

{nodebpy-520.32.0 → nodebpy-520.33.0}/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.