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

nodebpy/nodes/vector.py

@@ -0,0 +1,528 @@
+from typing import Literal
+
+import bpy
+
+from ..builder import NodeBuilder, SocketLinker
+from ..types import (
+    TYPE_INPUT_VALUE,
+    TYPE_INPUT_VECTOR,
+)
+
+
+class RadialTiling(NodeBuilder):
+    """Transform Coordinate System for Radial Tiling"""
+
+    _bl_idname = "ShaderNodeRadialTiling"
+    node: bpy.types.ShaderNodeRadialTiling
+
+    def __init__(
+        self,
+        vector: TYPE_INPUT_VECTOR = None,
+        sides: TYPE_INPUT_VALUE = 5.0,
+        roundness: TYPE_INPUT_VALUE = 0.0,
+        *,
+        normalize: bool = False,
+    ):
+        super().__init__()
+        key_args = {"Vector": vector, "Sides": sides, "Roundness": roundness}
+        self.normalize = normalize
+        self._establish_links(**key_args)
+
+    @property
+    def i_vector(self) -> SocketLinker:
+        """Input socket: Vector"""
+        return self._input("Vector")
+
+    @property
+    def i_sides(self) -> SocketLinker:
+        """Input socket: Sides"""
+        return self._input("Sides")
+
+    @property
+    def i_roundness(self) -> SocketLinker:
+        """Input socket: Roundness"""
+        return self._input("Roundness")
+
+    @property
+    def o_segment_coordinates(self) -> SocketLinker:
+        """Output socket: Segment Coordinates"""
+        return self._output("Segment Coordinates")
+
+    @property
+    def o_segment_id(self) -> SocketLinker:
+        """Output socket: Segment ID"""
+        return self._output("Segment ID")
+
+    @property
+    def o_segment_width(self) -> SocketLinker:
+        """Output socket: Segment Width"""
+        return self._output("Segment Width")
+
+    @property
+    def o_segment_rotation(self) -> SocketLinker:
+        """Output socket: Segment Rotation"""
+        return self._output("Segment Rotation")
+
+    @property
+    def normalize(self) -> bool:
+        return self.node.normalize
+
+    @normalize.setter
+    def normalize(self, value: bool):
+        self.node.normalize = value
+
+
+class VectorCurves(NodeBuilder):
+    """Map input vector components with curves"""
+
+    _bl_idname = "ShaderNodeVectorCurve"
+    node: bpy.types.ShaderNodeVectorCurve
+
+    def __init__(
+        self,
+        fac: TYPE_INPUT_VALUE = 1.0,
+        vector: TYPE_INPUT_VECTOR = None,
+    ):
+        super().__init__()
+        key_args = {"Fac": fac, "Vector": vector}
+
+        self._establish_links(**key_args)
+
+    @property
+    def i_fac(self) -> SocketLinker:
+        """Input socket: Factor"""
+        return self._input("Fac")
+
+    @property
+    def i_vector(self) -> SocketLinker:
+        """Input socket: Vector"""
+        return self._input("Vector")
+
+    @property
+    def o_vector(self) -> SocketLinker:
+        """Output socket: Vector"""
+        return self._output("Vector")
+
+
+class VectorMath(NodeBuilder):
+    """Perform vector math operation"""
+
+    _bl_idname = "ShaderNodeVectorMath"
+    node: bpy.types.ShaderNodeVectorMath
+
+    def __init__(
+        self,
+        vector: TYPE_INPUT_VECTOR = None,
+        vector_001: TYPE_INPUT_VECTOR = None,
+        vector_002: TYPE_INPUT_VECTOR = None,
+        scale: TYPE_INPUT_VALUE = 1.0,
+        *,
+        operation: Literal[
+            "ADD",
+            "SUBTRACT",
+            "MULTIPLY",
+            "DIVIDE",
+            "MULTIPLY_ADD",
+            "CROSS_PRODUCT",
+            "PROJECT",
+            "REFLECT",
+            "REFRACT",
+            "FACEFORWARD",
+            "DOT_PRODUCT",
+            "DISTANCE",
+            "LENGTH",
+            "SCALE",
+            "NORMALIZE",
+            "ABSOLUTE",
+            "POWER",
+            "SIGN",
+            "MINIMUM",
+            "MAXIMUM",
+            "FLOOR",
+            "CEIL",
+            "FRACTION",
+            "MODULO",
+            "WRAP",
+            "SNAP",
+            "SINE",
+            "COSINE",
+            "TANGENT",
+        ] = "ADD",
+    ):
+        super().__init__()
+        key_args = {
+            "Vector": vector,
+            "Vector_001": vector_001,
+            "Vector_002": vector_002,
+            "Scale": scale,
+        }
+        self.operation = operation
+        self._establish_links(**key_args)
+
+    @classmethod
+    def add(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Add'."""
+        return cls(operation="ADD", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def subtract(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Subtract'."""
+        return cls(operation="SUBTRACT", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def multiply(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Multiply'."""
+        return cls(operation="MULTIPLY", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def divide(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Divide'."""
+        return cls(operation="DIVIDE", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def project(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Project'."""
+        return cls(operation="PROJECT", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def reflect(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Reflect'."""
+        return cls(operation="REFLECT", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def refract(
+        cls,
+        vector: TYPE_INPUT_VECTOR = None,
+        vector_001: TYPE_INPUT_VECTOR = None,
+        scale: TYPE_INPUT_VALUE = 1.0,
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Refract'."""
+        return cls(
+            operation="REFRACT", vector=vector, vector_001=vector_001, scale=scale
+        )
+
+    @classmethod
+    def faceforward(
+        cls,
+        vector: TYPE_INPUT_VECTOR = None,
+        vector_001: TYPE_INPUT_VECTOR = None,
+        vector_002: TYPE_INPUT_VECTOR = None,
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Faceforward'."""
+        return cls(
+            operation="FACEFORWARD",
+            vector=vector,
+            vector_001=vector_001,
+            vector_002=vector_002,
+        )
+
+    @classmethod
+    def distance(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Distance'."""
+        return cls(operation="DISTANCE", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def length(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Length'."""
+        return cls(operation="LENGTH", vector=vector)
+
+    @classmethod
+    def scale(
+        cls, vector: TYPE_INPUT_VECTOR = None, scale: TYPE_INPUT_VALUE = 1.0
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Scale'."""
+        return cls(operation="SCALE", vector=vector, scale=scale)
+
+    @classmethod
+    def normalize(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Normalize'."""
+        return cls(operation="NORMALIZE", vector=vector)
+
+    @classmethod
+    def absolute(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Absolute'."""
+        return cls(operation="ABSOLUTE", vector=vector)
+
+    @classmethod
+    def power(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Power'."""
+        return cls(operation="POWER", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def sign(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Sign'."""
+        return cls(operation="SIGN", vector=vector)
+
+    @classmethod
+    def minimum(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Minimum'."""
+        return cls(operation="MINIMUM", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def maximum(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Maximum'."""
+        return cls(operation="MAXIMUM", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def floor(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Floor'."""
+        return cls(operation="FLOOR", vector=vector)
+
+    @classmethod
+    def ceil(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Ceil'."""
+        return cls(operation="CEIL", vector=vector)
+
+    @classmethod
+    def fraction(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Fraction'."""
+        return cls(operation="FRACTION", vector=vector)
+
+    @classmethod
+    def modulo(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Modulo'."""
+        return cls(operation="MODULO", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def wrap(
+        cls,
+        vector: TYPE_INPUT_VECTOR = None,
+        vector_001: TYPE_INPUT_VECTOR = None,
+        vector_002: TYPE_INPUT_VECTOR = None,
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Wrap'."""
+        return cls(
+            operation="WRAP",
+            vector=vector,
+            vector_001=vector_001,
+            vector_002=vector_002,
+        )
+
+    @classmethod
+    def snap(
+        cls, vector: TYPE_INPUT_VECTOR = None, vector_001: TYPE_INPUT_VECTOR = None
+    ) -> "VectorMath":
+        """Create Vector Math with operation 'Snap'."""
+        return cls(operation="SNAP", vector=vector, vector_001=vector_001)
+
+    @classmethod
+    def sine(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Sine'."""
+        return cls(operation="SINE", vector=vector)
+
+    @classmethod
+    def cosine(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Cosine'."""
+        return cls(operation="COSINE", vector=vector)
+
+    @classmethod
+    def tangent(cls, vector: TYPE_INPUT_VECTOR = None) -> "VectorMath":
+        """Create Vector Math with operation 'Tangent'."""
+        return cls(operation="TANGENT", vector=vector)
+
+    @property
+    def i_vector(self) -> SocketLinker:
+        """Input socket: Vector"""
+        return self._input("Vector")
+
+    @property
+    def i_vector_001(self) -> SocketLinker:
+        """Input socket: Vector"""
+        return self._input("Vector_001")
+
+    @property
+    def i_vector_002(self) -> SocketLinker:
+        """Input socket: Vector"""
+        return self._input("Vector_002")
+
+    @property
+    def i_scale(self) -> SocketLinker:
+        """Input socket: Scale"""
+        return self._input("Scale")
+
+    @property
+    def o_vector(self) -> SocketLinker:
+        """Output socket: Vector"""
+        return self._output("Vector")
+
+    @property
+    def o_value(self) -> SocketLinker:
+        """Output socket: Value"""
+        return self._output("Value")
+
+    @property
+    def operation(
+        self,
+    ) -> Literal[
+        "ADD",
+        "SUBTRACT",
+        "MULTIPLY",
+        "DIVIDE",
+        "MULTIPLY_ADD",
+        "CROSS_PRODUCT",
+        "PROJECT",
+        "REFLECT",
+        "REFRACT",
+        "FACEFORWARD",
+        "DOT_PRODUCT",
+        "DISTANCE",
+        "LENGTH",
+        "SCALE",
+        "NORMALIZE",
+        "ABSOLUTE",
+        "POWER",
+        "SIGN",
+        "MINIMUM",
+        "MAXIMUM",
+        "FLOOR",
+        "CEIL",
+        "FRACTION",
+        "MODULO",
+        "WRAP",
+        "SNAP",
+        "SINE",
+        "COSINE",
+        "TANGENT",
+    ]:
+        return self.node.operation
+
+    @operation.setter
+    def operation(
+        self,
+        value: Literal[
+            "ADD",
+            "SUBTRACT",
+            "MULTIPLY",
+            "DIVIDE",
+            "MULTIPLY_ADD",
+            "CROSS_PRODUCT",
+            "PROJECT",
+            "REFLECT",
+            "REFRACT",
+            "FACEFORWARD",
+            "DOT_PRODUCT",
+            "DISTANCE",
+            "LENGTH",
+            "SCALE",
+            "NORMALIZE",
+            "ABSOLUTE",
+            "POWER",
+            "SIGN",
+            "MINIMUM",
+            "MAXIMUM",
+            "FLOOR",
+            "CEIL",
+            "FRACTION",
+            "MODULO",
+            "WRAP",
+            "SNAP",
+            "SINE",
+            "COSINE",
+            "TANGENT",
+        ],
+    ):
+        self.node.operation = value
+
+
+class VectorRotate(NodeBuilder):
+    """Rotate a vector around a pivot point (center)"""
+
+    _bl_idname = "ShaderNodeVectorRotate"
+    node: bpy.types.ShaderNodeVectorRotate
+
+    def __init__(
+        self,
+        vector: TYPE_INPUT_VECTOR = None,
+        center: TYPE_INPUT_VECTOR = None,
+        axis: TYPE_INPUT_VECTOR = None,
+        angle: TYPE_INPUT_VALUE = 0.0,
+        rotation: TYPE_INPUT_VECTOR = None,
+        *,
+        rotation_type: Literal[
+            "AXIS_ANGLE", "X_AXIS", "Y_AXIS", "Z_AXIS", "EULER_XYZ"
+        ] = "AXIS_ANGLE",
+        invert: bool = False,
+    ):
+        super().__init__()
+        key_args = {
+            "Vector": vector,
+            "Center": center,
+            "Axis": axis,
+            "Angle": angle,
+            "Rotation": rotation,
+        }
+        self.rotation_type = rotation_type
+        self.invert = invert
+        self._establish_links(**key_args)
+
+    @property
+    def i_vector(self) -> SocketLinker:
+        """Input socket: Vector"""
+        return self._input("Vector")
+
+    @property
+    def i_center(self) -> SocketLinker:
+        """Input socket: Center"""
+        return self._input("Center")
+
+    @property
+    def i_axis(self) -> SocketLinker:
+        """Input socket: Axis"""
+        return self._input("Axis")
+
+    @property
+    def i_angle(self) -> SocketLinker:
+        """Input socket: Angle"""
+        return self._input("Angle")
+
+    @property
+    def i_rotation(self) -> SocketLinker:
+        """Input socket: Rotation"""
+        return self._input("Rotation")
+
+    @property
+    def o_vector(self) -> SocketLinker:
+        """Output socket: Vector"""
+        return self._output("Vector")
+
+    @property
+    def rotation_type(
+        self,
+    ) -> Literal["AXIS_ANGLE", "X_AXIS", "Y_AXIS", "Z_AXIS", "EULER_XYZ"]:
+        return self.node.rotation_type
+
+    @rotation_type.setter
+    def rotation_type(
+        self, value: Literal["AXIS_ANGLE", "X_AXIS", "Y_AXIS", "Z_AXIS", "EULER_XYZ"]
+    ):
+        self.node.rotation_type = value
+
+    @property
+    def invert(self) -> bool:
+        return self.node.invert
+
+    @invert.setter
+    def invert(self, value: bool):
+        self.node.invert = value

nodebpy/nodes/zone.py

@@ -6,7 +6,7 @@ from bpy.types import NodeSocket
 
 from nodebpy.builder import NodeBuilder, SocketLinker
 
-from .types import (
+from ..types import (
     LINKABLE,
     TYPE_INPUT_BOOLEAN,
     TYPE_INPUT_GEOMETRY,
@@ -194,7 +194,7 @@ class BaseSimulationZone(BaseZone):
 class SimulationInput(BaseSimulationZone, BaseZoneInput):
     """Simulation Input node"""
 
-    name = "GeometryNodeSimulationInput"
+    _bl_idname = "GeometryNodeSimulationInput"
     node: bpy.types.GeometryNodeSimulationInput
 
     @property
@@ -206,7 +206,7 @@ class SimulationInput(BaseSimulationZone, BaseZoneInput):
 class SimulationOutput(BaseSimulationZone, BaseZoneOutput):
     """Simulation Output node"""
 
-    name = "GeometryNodeSimulationOutput"
+    _bl_idname = "GeometryNodeSimulationOutput"
     node: bpy.types.GeometryNodeSimulationOutput
 
     @property
@@ -257,7 +257,7 @@ class BaseRepeatZone(BaseZone):
 class RepeatInput(BaseRepeatZone, BaseZoneInput):
     """Repeat Input node"""
 
-    name = "GeometryNodeRepeatInput"
+    _bl_idname = "GeometryNodeRepeatInput"
     node: bpy.types.GeometryNodeRepeatInput
 
     def __init__(self, iterations: TYPE_INPUT_INT = 1):
@@ -280,14 +280,14 @@ class RepeatInput(BaseRepeatZone, BaseZoneInput):
 class RepeatOutput(BaseRepeatZone, BaseZoneOutput):
     """Repeat Output node"""
 
-    name = "GeometryNodeRepeatOutput"
+    _bl_idname = "GeometryNodeRepeatOutput"
     node: bpy.types.GeometryNodeRepeatOutput
 
 
 class ForEachGeometryElementInput(NodeBuilder):
     """For Each Geometry Element Input node"""
 
-    name = "GeometryNodeForeachGeometryElementInput"
+    _bl_idname = "GeometryNodeForeachGeometryElementInput"
     node: bpy.types.GeometryNodeForeachGeometryElementInput
 
     def __init__(
@@ -332,7 +332,7 @@ class ForEachGeometryElementInput(NodeBuilder):
 class ForEachGeometryElementOutput(NodeBuilder):
     """For Each Geometry Element Output node"""
 
-    name = "GeometryNodeForeachGeometryElementOutput"
+    _bl_idname = "GeometryNodeForeachGeometryElementOutput"
     node: bpy.types.GeometryNodeForeachGeometryElementOutput
 
     def __init__(

nodebpy/{nodes/types.py → types.py}

@@ -6,6 +6,8 @@ from typing import Literal
 from bpy.types import (
     NodeSocket,
     NodeSocketBool,
+    NodeSocketBundle,
+    NodeSocketClosure,
     NodeSocketCollection,
     NodeSocketColor,
     NodeSocketFloat,
@@ -22,7 +24,7 @@ from bpy.types import (
 from mathutils import Euler
 
 if typing.TYPE_CHECKING:
-    from ..builder import NodeBuilder, SocketLinker
+    from .builder import NodeBuilder, SocketLinker
 
 
 def _is_default_value(value: TYPE_INPUT_ALL):
@@ -67,6 +69,17 @@ TYPE_INPUT_GRID = typing.Union[
     TYPE_INPUT_VALUE, TYPE_INPUT_VECTOR, TYPE_INPUT_BOOLEAN, TYPE_INPUT_INT
 ]
 TYPE_INPUT_MENU = typing.Union[LINKABLE, NodeSocketMenu]
+TYPE_INPUT_BUNDLE = typing.Union[LINKABLE, NodeSocketBundle]
+TYPE_INPUT_CLOSURE = typing.Union[LINKABLE, NodeSocketClosure]
+
+TYPE_INPUT_DATA = typing.Union[
+    TYPE_INPUT_VALUE,
+    TYPE_INPUT_INT,
+    TYPE_INPUT_BOOLEAN,
+    TYPE_INPUT_VECTOR,
+    TYPE_INPUT_ROTATION,
+    TYPE_INPUT_MATRIX,
+]
 
 TYPE_INPUT_ALL = typing.Union[
     TYPE_INPUT_VALUE,

{nodebpy-0.2.0.dist-info → nodebpy-0.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.2.0
+Version: 0.2.1
 Summary: Build nodes in Blender with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
@@ -76,7 +76,7 @@ with TreeBuilder("AnotherTree") as tree:
 
     _ = (
         count
-        >> n.Points(position=n.RandomValue.vector(min=(-1, -1, -1)))
+        >> n.Points(position=n.RandomValue.vector(min=-1))
         >> n.InstanceOnPoints(instance=n.Cube(), rotation=rotation)
         >> n.SetPosition(
             position=n.Position() * 2.0 + (0, 0.2, 0.3),

nodebpy-0.2.1.dist-info/RECORD

@@ -0,0 +1,26 @@
+nodebpy/__init__.py,sha256=AcXaVEPnvX1BlraPSSQ-0NR-Ip6cI0WNRqz84xvrTok,285
+nodebpy/arrange.py,sha256=xBHf-lYlvr-BCdI0gHhEn1ETWjEQyYmzgmhIZ1RYal8,11020
+nodebpy/builder.py,sha256=n4Qje1UAWUvOVCFv7KRaF6jDw6kEZPaVcWNLrqNHKlU,52460
+nodebpy/nodes/__init__.py,sha256=OKVeUcCUjhmqsEsGKhgkCVe0iq2dWEqJCgcogx9RShM,12528
+nodebpy/nodes/attribute.py,sha256=hme17msRejaqGHKDwvauHdCKMq7OLZhhi1Ax9Oxb7Wo,15043
+nodebpy/nodes/color.py,sha256=ye1LkcJuebjMlJ8OUlKepSOe8-dhImgoL1uXFG1NamE,1652
+nodebpy/nodes/converter.py,sha256=rzp3LmQ8uiDW1sDZg9x-LWkphBFzUn9dCgzETPI5Cdc,99014
+nodebpy/nodes/experimental.py,sha256=Gxd2lKD5Hr4ClSmFojeZpZQr5AapQebDgTeO9R6EqxE,9561
+nodebpy/nodes/geometry.py,sha256=C1H9JIGtzmzbJY7rsEf8c9PkX6Ja0JUKRcAI6uLS-l4,177510
+nodebpy/nodes/grid.py,sha256=Px92tPr9w-_IWdAzaMMaIbVeRAHWFTQF3QJ1FYPMqGc,50345
+nodebpy/nodes/group.py,sha256=PzQ20PrzgtqgQ2XRU7K1pqA9mW5wyt54bUIaqHjdqD0,289
+nodebpy/nodes/input.py,sha256=i4CmSe4mBxlIru-BnzwUH1C_95Op5JpIMd-QiZY-FWE,60082
+nodebpy/nodes/interface.py,sha256=jobDdF_DpioS25-RfnyPLiKcA40ZfwNhOjdLATBHdDk,14947
+nodebpy/nodes/manual.py,sha256=zhfcbWJxB-lMB6q_fvmPjnYCRbS52gY-BI1171rIu9U,59625
+nodebpy/nodes/output.py,sha256=py1SgNLQfwTG31KQCHFZn6lC5qg8NixMAoJ1KhnT7XQ,2138
+nodebpy/nodes/texture.py,sha256=JyjsE8WrVJ4wpx3xO6uaJ5A8ll7N6FtWBQs0comAD7s,25526
+nodebpy/nodes/vector.py,sha256=ULEOGx71OCD1Rz2egzkz5RhaKc5huC-LUjghovrnPbQ,15283
+nodebpy/nodes/zone.py,sha256=Rc97fUW1PmteAzxODCEpGJbVbfl9PTgnnBHSoBa8188,13543
+nodebpy/screenshot.py,sha256=gXAwGfeK05YL9XIpghv5nQ5cXVgtR35wnLnTVDAh08g,18885
+nodebpy/screenshot_subprocess.py,sha256=bmuyjedROCasEDI-JdjXWVsYoEX5I-asE3KxMVR30qM,15364
+nodebpy/sockets.py,sha256=eU3p0IdCkYQeVRp8XkkDuOR38JTIzniTXKhsXQgx29Q,1011
+nodebpy/types.py,sha256=4IGYzFquYFPNj_h-yKz-VycdodozdaaHSJ9gX6MchTs,10848
+nodebpy-0.2.1.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+nodebpy-0.2.1.dist-info/entry_points.txt,sha256=XvODbWiwSnneYWIYjxFJZmXdntQnapg59Ye2LtCKEN4,42
+nodebpy-0.2.1.dist-info/METADATA,sha256=sHU0fV0C_fUtJaPVR8-xkwxX_6FQ-TieLoT7IZRBdkA,6289
+nodebpy-0.2.1.dist-info/RECORD,,

nodebpy/nodes/mesh.py

@@ -1,17 +0,0 @@
-"""
-Auto-generated Blender Geometry Node classes.
-
-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