nodebpy 0.14.0__tar.gz → 0.15.1__tar.gz

{nodebpy-0.14.0 → nodebpy-0.15.1}/PKG-INFO

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

{nodebpy-0.14.0 → nodebpy-0.15.1}/pyproject.toml

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

{nodebpy-0.14.0 → nodebpy-0.15.1}/src/nodebpy/builder/socket.py

@@ -30,17 +30,36 @@ from bpy.types import (
 )
 from mathutils import Euler
 
-
-from ..types import SOCKET_TYPES
+from ..types import (
+    SOCKET_TYPES,
+    InputBoolean,
+    InputBundle,
+    InputClosure,
+    InputCollection,
+    InputColor,
+    InputFloat,
+    InputFont,
+    InputGeometry,
+    InputImage,
+    InputInteger,
+    InputMaterial,
+    InputMatrix,
+    InputMenu,
+    InputObject,
+    InputRotation,
+    InputString,
+    InputVector,
+)
 from ._registry import _SOCKET_LINKER_REGISTRY, _get_socket_linker
 from ._utils import _NodeLike, _SocketLike
 from .mixins import LinkingMixin, OperatorMixin
 
 if TYPE_CHECKING:
-    from ..nodes.geometry.converter import (
+    from ..nodes.geometry import (
         IntegerMath,
         Math,
         MultiplyMatrices,
+        Switch,
         TransformPoint,
     )
     from ..nodes.geometry.manual import Compare
@@ -587,6 +606,99 @@ class _IntegerMixin(BaseSocket):
 # ---------------------------------------------------------------------------
 
 
+class _BooleanSwitchSocketFactory:
+    def __init__(self, socket: NodeSocketBool):
+        self._socket = socket
+        from ..nodes.geometry import Switch
+
+        self._switch = Switch
+
+    def float(
+        self, false: InputFloat = None, true: InputFloat = None
+    ) -> "Switch[FloatSocket]":
+        return self._switch.float(self._socket, false, true)
+
+    def integer(
+        self, false: InputInteger = None, true: InputInteger = None
+    ) -> "Switch[IntegerSocket]":
+        return self._switch.integer(self._socket, false, true)
+
+    def boolean(
+        self, false: InputBoolean = None, true: InputBoolean = None
+    ) -> "Switch[BooleanSocket]":
+        return self._switch.boolean(self._socket, false, true)
+
+    def vector(
+        self, false: InputVector = None, true: InputVector = None
+    ) -> "Switch[VectorSocket]":
+        return self._switch.vector(self._socket, false, true)
+
+    def color(
+        self, false: InputColor = None, true: InputColor = None
+    ) -> "Switch[ColorSocket]":
+        return self._switch.color(self._socket, false, true)
+
+    def rotation(
+        self, false: InputRotation = None, true: InputRotation = None
+    ) -> "Switch[RotationSocket]":
+        return self._switch.rotation(self._socket, false, true)
+
+    def matrix(
+        self, false: InputMatrix = None, true: InputMatrix = None
+    ) -> "Switch[MatrixSocket]":
+        return self._switch.matrix(self._socket, false, true)
+
+    def string(
+        self, false: InputString = None, true: InputString = None
+    ) -> "Switch[StringSocket]":
+        return self._switch.string(self._socket, false, true)
+
+    def menu(
+        self, false: InputMenu = None, true: InputMenu = None
+    ) -> "Switch[MenuSocket]":
+        return self._switch.menu(self._socket, false, true)
+
+    def object(
+        self, false: InputObject = None, true: InputObject = None
+    ) -> "Switch[ObjectSocket]":
+        return self._switch.object(self._socket, false, true)
+
+    def image(
+        self, false: InputImage = None, true: InputImage = None
+    ) -> "Switch[ImageSocket]":
+        return self._switch.image(self._socket, false, true)
+
+    def geometry(
+        self, false: InputGeometry = None, true: InputGeometry = None
+    ) -> "Switch[GeometrySocket]":
+        return self._switch.geometry(self._socket, false, true)
+
+    def collection(
+        self, false: InputCollection = None, true: InputCollection = None
+    ) -> "Switch[CollectionSocket]":
+        return self._switch.collection(self._socket, false, true)
+
+    def material(
+        self, false: InputMaterial = None, true: InputMaterial = None
+    ) -> "Switch[MaterialSocket]":
+        return self._switch.material(self._socket, false, true)
+
+    def bundle(
+        self, false: InputBundle = None, true: InputBundle = None
+    ) -> "Switch[BundleSocket]":
+        return self._switch.bundle(self._socket, false, true)
+
+    def closure(
+        self, false: InputClosure = None, true: InputClosure = None
+    ) -> "Switch[ClosureSocket]":
+        return self._switch.closure(self._socket, false, true)
+
+    def font(
+        self, false: InputFont = None, true: InputFont = None
+    ) -> "Switch[FontSocket]":
+        return self._switch.font(self._socket, false, true)
+
+
 class _BooleanMixin(BaseSocket):
     """Boolean-specific operator overrides — routes directly through BooleanMath."""
 
@@ -610,6 +722,12 @@ class _BooleanMixin(BaseSocket):
 
         return BooleanMath.l_and(self.socket, other)
 
+    @property
+    def switch(self) -> "_BooleanSwitchSocketFactory":
+        "Creat a Switch node with this boolean as the `switch` input."
+
+        return _BooleanSwitchSocketFactory(self.socket)
+
 
 class _RotationMixin(BaseSocket):
     """Rotation-specific properties (.w, .x, .y, .z) via RotationToQuaternion."""

{nodebpy-0.14.0 → nodebpy-0.15.1}/src/nodebpy/nodes/geometry/__init__.py

@@ -5,12 +5,12 @@ from .manual import (
     HandleTypeSelection,
     IndexSwitch,
     MenuSwitch,
+    Switch,
     CaptureAttribute,
     FieldToGrid,
     JoinGeometry,
     SDFGridBoolean,
     Bake,
-    JoinStrings,
     GeometryToInstance,
     RepeatInput,
     RepeatOutput,
@@ -26,6 +26,7 @@ from .manual import (
     ClosureOutput,
     ClosureZone,
     FormatString,
+    JoinStrings,
     Collection,
     Material,
     Object,
@@ -43,6 +44,9 @@ from .manual import (
     SampleCurve,
     Frame,
     Float,
+    FloatCurve,
+    ColorRamp,
+    StoreNamedAttribute,
     tree,
 )
 from .converter import (
@@ -53,7 +57,6 @@ from .converter import (
     Blackbody,
     BooleanMath,
     Clamp,
-    ColorRamp,
     CombineBundle,
     CombineColor,
     CombineMatrix,
@@ -61,7 +64,6 @@ from .converter import (
     CombineXYZ,
     EulerToRotation,
     FindInString,
-    FloatCurve,
     FloatToInteger,
     GetBundleItem,
     HashValue,
@@ -97,7 +99,6 @@ from .converter import (
     StoreBundleItem,
     StringLength,
     StringToValue,
-    Switch,
     TransformDirection,
     TransformPoint,
     TransposeMatrix,
@@ -186,7 +187,6 @@ from .attribute import (
     BlurAttribute,
     DomainSize,
     RemoveNamedAttribute,
-    StoreNamedAttribute,
 )
 from .geometry import (
     Arc,
@@ -521,6 +521,7 @@ __all__ = (
     "JoinBundle",
     "JoinGeometry",
     "JoinStrings",
+    "JoinStrings",
     "LinearGizmo",
     "MagicTexture",
     "MapRange",

nodebpy-0.15.1/src/nodebpy/nodes/geometry/attribute.py

@@ -0,0 +1,291 @@
+# Auto-generated by generate.py — do not edit manually.
+
+from typing import TYPE_CHECKING, Literal
+
+import bpy
+
+from ...builder import (
+    BaseNode as BaseNode,
+    SocketAccessor,
+    FloatSocket,
+    GeometrySocket,
+    IntegerSocket,
+    MenuSocket,
+    StringSocket,
+)
+
+from ...types import (
+    InputColor,
+    InputGeometry,
+    InputInteger,
+    InputMenu,
+    InputString,
+    InputFloat,
+    InputVector,
+)
+
+
+class BlurAttribute(BaseNode):
+    """
+    Mix attribute values of neighboring elements
+
+    Parameters
+    ----------
+    value : InputFloat
+        Value
+    iterations : InputInteger
+        Iterations
+    weight : InputFloat
+        Weight
+
+    Inputs
+    ------
+    i.value : FloatSocket
+        Value
+    i.iterations : IntegerSocket
+        Iterations
+    i.weight : FloatSocket
+        Weight
+
+    Outputs
+    -------
+    o.value : FloatSocket
+        Value
+    """
+
+    _bl_idname = "GeometryNodeBlurAttribute"
+    node: bpy.types.GeometryNodeBlurAttribute
+
+    class _Inputs(SocketAccessor):
+        value: FloatSocket
+        """Value"""
+        iterations: IntegerSocket
+        """Iterations"""
+        weight: FloatSocket
+        """Weight"""
+
+    class _Outputs(SocketAccessor):
+        value: FloatSocket
+        """Value"""
+
+    if TYPE_CHECKING:
+
+        @property
+        def i(self) -> _Inputs: ...
+        @property
+        def o(self) -> _Outputs: ...
+
+    def __init__(
+        self,
+        value: InputFloat = 0.0,
+        iterations: InputInteger = 1,
+        weight: InputFloat = 1.0,
+        *,
+        data_type: Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"] = "FLOAT",
+    ):
+        super().__init__()
+        key_args = {"Value": value, "Iterations": iterations, "Weight": weight}
+        self.data_type = data_type
+        self._establish_links(**key_args)
+
+    @classmethod
+    def float(
+        cls,
+        value: InputFloat = 0.0,
+        iterations: InputInteger = 1,
+        weight: InputFloat = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Float'. Floating-point value"""
+        return cls(data_type="FLOAT", value=value, iterations=iterations, weight=weight)
+
+    @classmethod
+    def integer(
+        cls,
+        value: InputInteger = 0,
+        iterations: InputInteger = 1,
+        weight: InputFloat = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Integer'. 32-bit integer"""
+        return cls(data_type="INT", value=value, iterations=iterations, weight=weight)
+
+    @classmethod
+    def vector(
+        cls,
+        value: InputVector = None,
+        iterations: InputInteger = 1,
+        weight: InputFloat = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Vector'. 3D vector with floating-point values"""
+        return cls(
+            data_type="FLOAT_VECTOR", value=value, iterations=iterations, weight=weight
+        )
+
+    @classmethod
+    def color(
+        cls,
+        value: InputColor = None,
+        iterations: InputInteger = 1,
+        weight: InputFloat = 1.0,
+    ) -> "BlurAttribute":
+        """Create Blur Attribute with operation 'Color'. RGBA color with 32-bit floating-point values"""
+        return cls(
+            data_type="FLOAT_COLOR", value=value, iterations=iterations, weight=weight
+        )
+
+    @property
+    def data_type(self) -> Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"]:
+        return self.node.data_type
+
+    @data_type.setter
+    def data_type(self, value: Literal["FLOAT", "INT", "FLOAT_VECTOR", "FLOAT_COLOR"]):
+        self.node.data_type = value
+
+
+class DomainSize(BaseNode):
+    """
+    Retrieve the number of elements in a geometry for each attribute domain
+
+    Parameters
+    ----------
+    geometry : InputGeometry
+        Geometry
+
+    Inputs
+    ------
+    i.geometry : GeometrySocket
+        Geometry
+
+    Outputs
+    -------
+    o.point_count : IntegerSocket
+        Point Count
+    o.edge_count : IntegerSocket
+        Edge Count
+    o.face_count : IntegerSocket
+        Face Count
+    o.face_corner_count : IntegerSocket
+        Face Corner Count
+    o.spline_count : IntegerSocket
+        Spline Count
+    o.instance_count : IntegerSocket
+        Instance Count
+    o.layer_count : IntegerSocket
+        Layer Count
+    """
+
+    _bl_idname = "GeometryNodeAttributeDomainSize"
+    node: bpy.types.GeometryNodeAttributeDomainSize
+
+    class _Inputs(SocketAccessor):
+        geometry: GeometrySocket
+        """Geometry"""
+
+    class _Outputs(SocketAccessor):
+        point_count: IntegerSocket
+        """Point Count"""
+        edge_count: IntegerSocket
+        """Edge Count"""
+        face_count: IntegerSocket
+        """Face Count"""
+        face_corner_count: IntegerSocket
+        """Face Corner Count"""
+        spline_count: IntegerSocket
+        """Spline Count"""
+        instance_count: IntegerSocket
+        """Instance Count"""
+        layer_count: IntegerSocket
+        """Layer Count"""
+
+    if TYPE_CHECKING:
+
+        @property
+        def i(self) -> _Inputs: ...
+        @property
+        def o(self) -> _Outputs: ...
+
+    def __init__(
+        self,
+        geometry: InputGeometry = None,
+        *,
+        component: Literal[
+            "MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"
+        ] = "MESH",
+    ):
+        super().__init__()
+        key_args = {"Geometry": geometry}
+        self.component = component
+        self._establish_links(**key_args)
+
+    @property
+    def component(
+        self,
+    ) -> Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]:
+        return self.node.component
+
+    @component.setter
+    def component(
+        self, value: Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]
+    ):
+        self.node.component = value
+
+
+class RemoveNamedAttribute(BaseNode):
+    """
+    Delete an attribute with a specified name from a geometry. Typically used to optimize performance
+
+    Parameters
+    ----------
+    geometry : InputGeometry
+        Geometry
+    pattern_mode : InputMenu | Literal['Exact', 'Wildcard']
+        Pattern Mode
+    name : InputString
+        Name
+
+    Inputs
+    ------
+    i.geometry : GeometrySocket
+        Geometry
+    i.pattern_mode : MenuSocket
+        Pattern Mode
+    i.name : StringSocket
+        Name
+
+    Outputs
+    -------
+    o.geometry : GeometrySocket
+        Geometry
+    """
+
+    _bl_idname = "GeometryNodeRemoveAttribute"
+    node: bpy.types.GeometryNodeRemoveAttribute
+
+    class _Inputs(SocketAccessor):
+        geometry: GeometrySocket
+        """Geometry"""
+        pattern_mode: MenuSocket
+        """Pattern Mode"""
+        name: StringSocket
+        """Name"""
+
+    class _Outputs(SocketAccessor):
+        geometry: GeometrySocket
+        """Geometry"""
+
+    if TYPE_CHECKING:
+
+        @property
+        def i(self) -> _Inputs: ...
+        @property
+        def o(self) -> _Outputs: ...
+
+    def __init__(
+        self,
+        geometry: InputGeometry = None,
+        pattern_mode: InputMenu | Literal["Exact", "Wildcard"] = "Exact",
+        name: InputString = "",
+    ):
+        super().__init__()
+        key_args = {"Geometry": geometry, "Pattern Mode": pattern_mode, "Name": name}
+
+        self._establish_links(**key_args)