nodebpy 0.1.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

nodebpy/nodes/attribute.py

@@ -1,24 +1,20 @@
-"""
-Auto-generated Blender Geometry Node classes.
+from typing import Literal
 
-DO NOT EDIT THIS FILE MANUALLY.
-This file is generated by molecularnodes/nodes/generator.py
-
-To regenerate: Run generator.py from within Blender
-
-KNOWN LIMITATIONS:
-- Dynamic multi-input/output sockets are not yet supported
-  (these are the unnamed sockets that appear in the UI for nodes like
-  "Evaluate Closure", "Join Geometry", etc. that allow dragging in
-  multiple connections)
-- TODO: Add support for dynamic socket creation
-"""
-
-from __future__ import annotations
 import bpy
-from typing_extensions import Literal
-from ..builder import NodeBuilder, NodeSocket
-from .types import LINKABLE, TYPE_INPUT_BOOLEAN
+
+from ..builder import NodeBuilder, SocketLinker
+from .types import (
+    LINKABLE,
+    TYPE_INPUT_BOOLEAN,
+    TYPE_INPUT_GEOMETRY,
+    TYPE_INPUT_INT,
+    TYPE_INPUT_MENU,
+    TYPE_INPUT_STRING,
+    TYPE_INPUT_VALUE,
+    _AttributeDataTypes,
+    _AttributeDomains,
+    _StoreNamedAttributeTypes,
+)
 
 
 class DomainSize(NodeBuilder):
@@ -29,40 +25,39 @@ class DomainSize(NodeBuilder):
 
     def __init__(
         self,
-        geometry: LINKABLE = None,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        *,
         component: Literal[
             "MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"
         ] = "MESH",
-        **kwargs,
     ):
         super().__init__()
         key_args = {"Geometry": geometry}
-        key_args.update(kwargs)
         self.component = component
         self._establish_links(**key_args)
 
     @property
-    def i_geometry(self) -> NodeSocket:
+    def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
         return self._input("Geometry")
 
     @property
-    def o_point_count(self) -> bpy.types.NodeSocketInt:
+    def o_point_count(self) -> SocketLinker:
         """Output socket: Point Count"""
         return self._output("Point Count")
 
     @property
-    def o_edge_count(self) -> bpy.types.NodeSocketInt:
+    def o_edge_count(self) -> SocketLinker:
         """Output socket: Edge Count"""
         return self._output("Edge Count")
 
     @property
-    def o_face_count(self) -> bpy.types.NodeSocketInt:
+    def o_face_count(self) -> SocketLinker:
         """Output socket: Face Count"""
         return self._output("Face Count")
 
     @property
-    def o_face_corner_count(self) -> bpy.types.NodeSocketInt:
+    def o_face_corner_count(self) -> SocketLinker:
         """Output socket: Face Corner Count"""
         return self._output("Face Corner Count")
 
@@ -76,6 +71,13 @@ class DomainSize(NodeBuilder):
     def component(
         self, value: Literal["MESH", "POINTCLOUD", "CURVE", "INSTANCES", "GREASEPENCIL"]
     ):
+        match value:
+            case "MESH" | "POINTCLOUD" | "CURVE":
+                self._default_output_id = "Point Count"
+            case "INSTANCES":
+                self._default_output_id = "Instance Count"
+            case "GREASEPENCIL":
+                self._default_output_id = "Layer Count"
         self.node.component = value
 
 
@@ -87,23 +89,13 @@ class AttributeStatistic(NodeBuilder):
 
     def __init__(
         self,
-        geometry: LINKABLE = None,
+        geometry: TYPE_INPUT_GEOMETRY = None,
         selection: TYPE_INPUT_BOOLEAN = True,
-        attribute: float | LINKABLE | None = 0.0,
+        attribute: LINKABLE = None,
+        *,
         data_type: Literal[
             "FLOAT",
-            "INT",
-            "BOOLEAN",
             "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
         ] = "FLOAT",
         domain: Literal[
             "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
@@ -122,57 +114,57 @@ class AttributeStatistic(NodeBuilder):
         self._establish_links(**key_args)
 
     @property
-    def i_geometry(self) -> NodeSocket:
+    def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
         return self._input("Geometry")
 
     @property
-    def i_selection(self) -> bpy.types.NodeSocketBool:
+    def i_selection(self) -> SocketLinker:
         """Input socket: Selection"""
         return self._input("Selection")
 
     @property
-    def i_attribute(self) -> bpy.types.NodeSocketFloat:
+    def i_attribute(self) -> SocketLinker:
         """Input socket: Attribute"""
         return self._input("Attribute")
 
     @property
-    def o_mean(self) -> bpy.types.NodeSocketFloat:
+    def o_mean(self) -> SocketLinker:
         """Output socket: Mean"""
         return self._output("Mean")
 
     @property
-    def o_median(self) -> bpy.types.NodeSocketFloat:
+    def o_median(self) -> SocketLinker:
         """Output socket: Median"""
         return self._output("Median")
 
     @property
-    def o_sum(self) -> bpy.types.NodeSocketFloat:
+    def o_sum(self) -> SocketLinker:
         """Output socket: Sum"""
         return self._output("Sum")
 
     @property
-    def o_min(self) -> bpy.types.NodeSocketFloat:
+    def o_min(self) -> SocketLinker:
         """Output socket: Min"""
         return self._output("Min")
 
     @property
-    def o_max(self) -> bpy.types.NodeSocketFloat:
+    def o_max(self) -> SocketLinker:
         """Output socket: Max"""
         return self._output("Max")
 
     @property
-    def o_range(self) -> bpy.types.NodeSocketFloat:
+    def o_range(self) -> SocketLinker:
         """Output socket: Range"""
         return self._output("Range")
 
     @property
-    def o_standard_deviation(self) -> bpy.types.NodeSocketFloat:
+    def o_standard_deviation(self) -> SocketLinker:
         """Output socket: Standard Deviation"""
         return self._output("Standard Deviation")
 
     @property
-    def o_variance(self) -> bpy.types.NodeSocketFloat:
+    def o_variance(self) -> SocketLinker:
         """Output socket: Variance"""
         return self._output("Variance")
 
@@ -181,38 +173,16 @@ class AttributeStatistic(NodeBuilder):
         self,
     ) -> Literal[
         "FLOAT",
-        "INT",
-        "BOOLEAN",
         "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
     ]:
-        return self.node.data_type
+        return self.node.data_type  # type: ignore
 
     @data_type.setter
     def data_type(
         self,
         value: Literal[
             "FLOAT",
-            "INT",
-            "BOOLEAN",
             "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
         ],
     ):
         self.node.data_type = value
@@ -220,13 +190,13 @@ class AttributeStatistic(NodeBuilder):
     @property
     def domain(
         self,
-    ) -> Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"]:
+    ) -> _AttributeDomains:
         return self.node.domain
 
     @domain.setter
     def domain(
         self,
-        value: Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"],
+        value: _AttributeDomains,
     ):
         self.node.domain = value
 
@@ -239,49 +209,39 @@ class BlurAttribute(NodeBuilder):
 
     def __init__(
         self,
-        value: float | LINKABLE | None = 0.0,
-        iterations: int | LINKABLE | None = 1,
-        weight: LINKABLE | None = 1.0,
+        value: LINKABLE = None,
+        iterations: TYPE_INPUT_INT = 1,
+        weight: TYPE_INPUT_VALUE = 1.0,
+        *,
         data_type: Literal[
             "FLOAT",
             "INT",
-            "BOOLEAN",
             "FLOAT_VECTOR",
             "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
         ] = "FLOAT",
-        **kwargs,
     ):
         super().__init__()
         key_args = {"Value": value, "Iterations": iterations, "Weight": weight}
-        key_args.update(kwargs)
         self.data_type = data_type
         self._establish_links(**key_args)
 
     @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
+    def i_value(self) -> SocketLinker:
         """Input socket: Value"""
         return self._input("Value")
 
     @property
-    def i_iterations(self) -> bpy.types.NodeSocketInt:
+    def i_iterations(self) -> SocketLinker:
         """Input socket: Iterations"""
         return self._input("Iterations")
 
     @property
-    def i_weight(self) -> NodeSocket:
+    def i_weight(self) -> SocketLinker:
         """Input socket: Weight"""
         return self._input("Weight")
 
     @property
-    def o_value(self) -> bpy.types.NodeSocketFloat:
+    def o_value(self) -> SocketLinker:
         """Output socket: Value"""
         return self._output("Value")
 
@@ -291,19 +251,10 @@ class BlurAttribute(NodeBuilder):
     ) -> Literal[
         "FLOAT",
         "INT",
-        "BOOLEAN",
         "FLOAT_VECTOR",
         "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
     ]:
-        return self.node.data_type
+        return self.node.data_type  # type: ignore
 
     @data_type.setter
     def data_type(
@@ -311,106 +262,8 @@ class BlurAttribute(NodeBuilder):
         value: Literal[
             "FLOAT",
             "INT",
-            "BOOLEAN",
             "FLOAT_VECTOR",
             "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ],
-    ):
-        self.node.data_type = value
-
-
-class NamedAttribute(NodeBuilder):
-    """Retrieve the data of a specified attribute"""
-
-    name = "GeometryNodeInputNamedAttribute"
-    node: bpy.types.GeometryNodeInputNamedAttribute
-
-    def __init__(
-        self,
-        name: str | LINKABLE | None = "",
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ] = "FLOAT",
-        **kwargs,
-    ):
-        super().__init__()
-        key_args = {"Name": name}
-        key_args.update(kwargs)
-        self.data_type = data_type
-        self._establish_links(**key_args)
-
-    @property
-    def i_name(self) -> bpy.types.NodeSocketString:
-        """Input socket: Name"""
-        return self._input("Name")
-
-    @property
-    def o_attribute(self) -> bpy.types.NodeSocketFloat:
-        """Output socket: Attribute"""
-        return self._output("Attribute")
-
-    @property
-    def o_exists(self) -> bpy.types.NodeSocketBool:
-        """Output socket: Exists"""
-        return self._output("Exists")
-
-    @property
-    def data_type(
-        self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
-    ]:
-        return self.node.data_type
-
-    @data_type.setter
-    def data_type(
-        self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
         ],
     ):
         self.node.data_type = value
@@ -424,34 +277,31 @@ class RemoveNamedAttribute(NodeBuilder):
 
     def __init__(
         self,
-        geometry: LINKABLE = None,
-        pattern_mode: LINKABLE | None = "Exact",
-        name: str | LINKABLE | None = "",
-        **kwargs,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        pattern_mode: Literal["Exact", "Wildcard"] | TYPE_INPUT_MENU = "Exact",
+        name: TYPE_INPUT_STRING = "",
     ):
         super().__init__()
         key_args = {"Geometry": geometry, "Pattern Mode": pattern_mode, "Name": name}
-        key_args.update(kwargs)
-
         self._establish_links(**key_args)
 
     @property
-    def i_geometry(self) -> NodeSocket:
+    def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
         return self._input("Geometry")
 
     @property
-    def i_pattern_mode(self) -> NodeSocket:
+    def i_pattern_mode(self) -> SocketLinker:
         """Input socket: Pattern Mode"""
         return self._input("Pattern Mode")
 
     @property
-    def i_name(self) -> bpy.types.NodeSocketString:
+    def i_name(self) -> SocketLinker:
         """Input socket: Name"""
         return self._input("Name")
 
     @property
-    def o_geometry(self) -> NodeSocket:
+    def o_geometry(self) -> SocketLinker:
         """Output socket: Geometry"""
         return self._output("Geometry")
 
@@ -464,29 +314,13 @@ class StoreNamedAttribute(NodeBuilder):
 
     def __init__(
         self,
-        geometry: LINKABLE = None,
+        geometry: TYPE_INPUT_GEOMETRY = None,
         selection: TYPE_INPUT_BOOLEAN = True,
-        name: str | LINKABLE | None = "",
-        value: float | LINKABLE | None = 0.0,
-        data_type: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ] = "FLOAT",
-        domain: Literal[
-            "POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"
-        ] = "POINT",
-        **kwargs,
+        name: TYPE_INPUT_STRING = "",
+        value: LINKABLE = None,
+        *,
+        data_type: _StoreNamedAttributeTypes = "FLOAT",
+        domain: _AttributeDomains = "POINT",
     ):
         super().__init__()
         key_args = {
@@ -495,86 +329,153 @@ class StoreNamedAttribute(NodeBuilder):
             "Name": name,
             "Value": value,
         }
-        key_args.update(kwargs)
         self.data_type = data_type
         self.domain = domain
         self._establish_links(**key_args)
 
     @property
-    def i_geometry(self) -> NodeSocket:
+    def i_geometry(self) -> SocketLinker:
         """Input socket: Geometry"""
         return self._input("Geometry")
 
     @property
-    def i_selection(self) -> bpy.types.NodeSocketBool:
+    def i_selection(self) -> SocketLinker:
         """Input socket: Selection"""
         return self._input("Selection")
 
     @property
-    def i_name(self) -> bpy.types.NodeSocketString:
+    def i_name(self) -> SocketLinker:
         """Input socket: Name"""
         return self._input("Name")
 
     @property
-    def i_value(self) -> bpy.types.NodeSocketFloat:
+    def i_value(self) -> SocketLinker:
         """Input socket: Value"""
         return self._input("Value")
 
     @property
-    def o_geometry(self) -> NodeSocket:
+    def o_geometry(self) -> SocketLinker:
         """Output socket: Geometry"""
         return self._output("Geometry")
 
     @property
     def data_type(
         self,
-    ) -> Literal[
-        "FLOAT",
-        "INT",
-        "BOOLEAN",
-        "FLOAT_VECTOR",
-        "FLOAT_COLOR",
-        "QUATERNION",
-        "FLOAT4X4",
-        "STRING",
-        "INT8",
-        "INT16_2D",
-        "INT32_2D",
-        "FLOAT2",
-        "BYTE_COLOR",
-    ]:
-        return self.node.data_type
+    ) -> _StoreNamedAttributeTypes:
+        return self.node.data_type  # type: ignore
 
     @data_type.setter
     def data_type(
         self,
-        value: Literal[
-            "FLOAT",
-            "INT",
-            "BOOLEAN",
-            "FLOAT_VECTOR",
-            "FLOAT_COLOR",
-            "QUATERNION",
-            "FLOAT4X4",
-            "STRING",
-            "INT8",
-            "INT16_2D",
-            "INT32_2D",
-            "FLOAT2",
-            "BYTE_COLOR",
-        ],
+        value: _StoreNamedAttributeTypes,
     ):
         self.node.data_type = value
 
     @property
     def domain(
         self,
-    ) -> Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"]:
+    ) -> _AttributeDomains:
+        return self.node.domain
+
+    @domain.setter
+    def domain(
+        self,
+        value: _AttributeDomains,
+    ):
+        self.node.domain = value
+
+
+def _domain_capture_attribute(domain: _AttributeDomains):
+    @classmethod
+    def method(
+        cls,
+        *args: LINKABLE,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        **kwargs,
+    ) -> "CaptureAttribute":
+        """Create an IndexSwitch node with a pre-set domain"""
+        return cls(*args, geometry=geometry, domain=domain, **kwargs)
+
+    return method
+
+
+class CaptureAttribute(NodeBuilder):
+    """Store the result of a field on a geometry and output the data as a node socket. Allows remembering or interpolating data as the geometry changes, such as positions before deformation"""
+
+    name = "GeometryNodeCaptureAttribute"
+    node: bpy.types.GeometryNodeCaptureAttribute
+    point = _domain_capture_attribute("POINT")
+    edge = _domain_capture_attribute("EDGE")
+    face = _domain_capture_attribute("FACE")
+    corner = _domain_capture_attribute("CORNER")
+    curve = _domain_capture_attribute("CURVE")
+    instance = _domain_capture_attribute("INSTANCE")
+    layer = _domain_capture_attribute("LAYER")
+
+    def __init__(
+        self,
+        *args: LINKABLE,
+        geometry: TYPE_INPUT_GEOMETRY = None,
+        domain: _AttributeDomains = "POINT",
+        **kwargs,
+    ):
+        super().__init__()
+        key_args = {"Geometry": geometry}
+        self.domain = domain
+        key_args.update(self._add_inputs(*args, **kwargs))  # type: ignore
+        self._establish_links(**key_args)
+
+    def _add_socket(self, name: str, type: _AttributeDataTypes):
+        item = self.node.capture_items.new(socket_type=type, name=name)
+        return self.node.inputs[item.name]
+
+    def capture(self, value: LINKABLE) -> SocketLinker:
+        """Capture the value to store in the attribute
+
+        Return the SocketLinker for the output socket
+        """
+        # the _add_inputs returns a dictionary but we only want the first key
+        # because we are adding a single input
+        input_dict = self._add_inputs(value)
+        return SocketLinker(self.node.outputs[next(iter(input_dict))])
+
+    @property
+    def outputs(self) -> dict[str, SocketLinker]:
+        return {
+            item.name: SocketLinker(self.node.outputs[item.name])
+            for item in self.node.capture_items
+        }
+
+    @property
+    def inputs(self) -> dict[str, SocketLinker]:
+        return {
+            item.name: SocketLinker(self.node.inputs[item.name])
+            for item in self.node.capture_items
+        }
+
+    @property
+    def _items(self) -> bpy.types.NodeGeometryCaptureAttributeItems:
+        return self.node.capture_items
+
+    @property
+    def i_geometry(self) -> SocketLinker:
+        """Input socket: Geometry"""
+        return self._input("Geometry")
+
+    @property
+    def o_geometry(self) -> SocketLinker:
+        """Output socket: Geometry"""
+        return self._output("Geometry")
+
+    @property
+    def domain(
+        self,
+    ) -> _AttributeDomains:
         return self.node.domain
 
     @domain.setter
     def domain(
         self,
-        value: Literal["POINT", "EDGE", "FACE", "CORNER", "CURVE", "INSTANCE", "LAYER"],
+        value: _AttributeDomains,
     ):
         self.node.domain = value