nodebpy 0.3.0__py3-none-any.whl → 0.3.1__py3-none-any.whl

nodebpy/nodes/converter.py

@@ -24,7 +24,9 @@ from ..types import (
 
 
 class AlignRotationToVector(NodeBuilder):
-    """Orient a rotation along the given direction"""
+    """
+    Orient a rotation along the given direction
+    """
 
     _bl_idname = "FunctionNodeAlignRotationToVector"
     node: bpy.types.FunctionNodeAlignRotationToVector
@@ -82,7 +84,9 @@ class AlignRotationToVector(NodeBuilder):
 
 
 class AxesToRotation(NodeBuilder):
-    """Create a rotation from a primary and (ideally orthogonal) secondary axis"""
+    """
+    Create a rotation from a primary and (ideally orthogonal) secondary axis
+    """
 
     _bl_idname = "FunctionNodeAxesToRotation"
     node: bpy.types.FunctionNodeAxesToRotation
@@ -134,7 +138,9 @@ class AxesToRotation(NodeBuilder):
 
 
 class AxisAngleToRotation(NodeBuilder):
-    """Build a rotation from an axis and a rotation around that axis"""
+    """
+    Build a rotation from an axis and a rotation around that axis
+    """
 
     _bl_idname = "FunctionNodeAxisAngleToRotation"
     node: bpy.types.FunctionNodeAxisAngleToRotation
@@ -166,7 +172,9 @@ class AxisAngleToRotation(NodeBuilder):
 
 
 class BitMath(NodeBuilder):
-    """Perform bitwise operations on 32-bit integers"""
+    """
+    Perform bitwise operations on 32-bit integers
+    """
 
     _bl_idname = "FunctionNodeBitMath"
     node: bpy.types.FunctionNodeBitMath
@@ -194,6 +202,11 @@ class BitMath(NodeBuilder):
         """Create Bit Math with operation 'Or'."""
         return cls(operation="OR", a=a, b=b)
 
+    @classmethod
+    def exclusive_or(cls, a: TYPE_INPUT_INT = 0, b: TYPE_INPUT_INT = 0) -> "BitMath":
+        """Create Bit Math with operation 'Exclusive Or'."""
+        return cls(operation="XOR", a=a, b=b)
+
     @classmethod
     def l_not(cls, a: TYPE_INPUT_INT = 0) -> "BitMath":
         """Create Bit Math with operation 'Not'."""
@@ -239,7 +252,9 @@ class BitMath(NodeBuilder):
 
 
 class Blackbody(NodeBuilder):
-    """Convert a blackbody temperature to an RGB value"""
+    """
+    Convert a blackbody temperature to an RGB value
+    """
 
     _bl_idname = "ShaderNodeBlackbody"
     node: bpy.types.ShaderNodeBlackbody
@@ -262,7 +277,9 @@ class Blackbody(NodeBuilder):
 
 
 class BooleanMath(NodeBuilder):
-    """Perform a logical operation on the given boolean inputs"""
+    """
+    Perform a logical operation on the given boolean inputs
+    """
 
     _bl_idname = "FunctionNodeBooleanMath"
     node: bpy.types.FunctionNodeBooleanMath
@@ -304,6 +321,15 @@ class BooleanMath(NodeBuilder):
         """Create Boolean Math with operation 'Not'."""
         return cls(operation="NOT", boolean=boolean)
 
+    @classmethod
+    def not_and(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'Not And'."""
+        return cls(operation="NAND", boolean=boolean, boolean_001=boolean_001)
+
     @classmethod
     def nor(
         cls,
@@ -322,6 +348,15 @@ class BooleanMath(NodeBuilder):
         """Create Boolean Math with operation 'Equal'."""
         return cls(operation="XNOR", boolean=boolean, boolean_001=boolean_001)
 
+    @classmethod
+    def not_equal(
+        cls,
+        boolean: TYPE_INPUT_BOOLEAN = False,
+        boolean_001: TYPE_INPUT_BOOLEAN = False,
+    ) -> "BooleanMath":
+        """Create Boolean Math with operation 'Not Equal'."""
+        return cls(operation="XOR", boolean=boolean, boolean_001=boolean_001)
+
     @classmethod
     def imply(
         cls,
@@ -372,7 +407,9 @@ class BooleanMath(NodeBuilder):
 
 
 class Clamp(NodeBuilder):
-    """Clamp a value between a minimum and a maximum"""
+    """
+    Clamp a value between a minimum and a maximum
+    """
 
     _bl_idname = "ShaderNodeClamp"
     node: bpy.types.ShaderNodeClamp
@@ -420,7 +457,9 @@ class Clamp(NodeBuilder):
 
 
 class ColorRamp(NodeBuilder):
-    """Map values to colors with the use of a gradient"""
+    """
+    Map values to colors with the use of a gradient
+    """
 
     _bl_idname = "ShaderNodeValToRGB"
     node: bpy.types.ShaderNodeValToRGB
@@ -448,7 +487,9 @@ class ColorRamp(NodeBuilder):
 
 
 class CombineBundle(NodeBuilder):
-    """Combine multiple socket values into one."""
+    """
+    Combine multiple socket values into one.
+    """
 
     _bl_idname = "NodeCombineBundle"
     node: bpy.types.Node
@@ -474,7 +515,9 @@ class CombineBundle(NodeBuilder):
 
 
 class CombineColor(NodeBuilder):
-    """Combine four channels into a single color, based on a particular color model"""
+    """
+    Combine four channels into a single color, based on a particular color model
+    """
 
     _bl_idname = "FunctionNodeCombineColor"
     node: bpy.types.FunctionNodeCombineColor
@@ -528,7 +571,9 @@ class CombineColor(NodeBuilder):
 
 
 class CombineMatrix(NodeBuilder):
-    """Construct a 4x4 matrix from its individual values"""
+    """
+    Construct a 4x4 matrix from its individual values
+    """
 
     _bl_idname = "FunctionNodeCombineMatrix"
     node: bpy.types.FunctionNodeCombineMatrix
@@ -661,7 +706,9 @@ class CombineMatrix(NodeBuilder):
 
 
 class CombineTransform(NodeBuilder):
-    """Combine a translation vector, a rotation, and a scale vector into a transformation matrix"""
+    """
+    Combine a translation vector, a rotation, and a scale vector into a transformation matrix
+    """
 
     _bl_idname = "FunctionNodeCombineTransform"
     node: bpy.types.FunctionNodeCombineTransform
@@ -699,7 +746,9 @@ class CombineTransform(NodeBuilder):
 
 
 class CombineXYZ(NodeBuilder):
-    """Create a vector from X, Y, and Z components"""
+    """
+    Create a vector from X, Y, and Z components
+    """
 
     _bl_idname = "ShaderNodeCombineXYZ"
     node: bpy.types.ShaderNodeCombineXYZ
@@ -737,7 +786,9 @@ class CombineXYZ(NodeBuilder):
 
 
 class EulerToRotation(NodeBuilder):
-    """Build a rotation from separate angles around each axis"""
+    """
+    Build a rotation from separate angles around each axis
+    """
 
     _bl_idname = "FunctionNodeEulerToRotation"
     node: bpy.types.FunctionNodeEulerToRotation
@@ -760,7 +811,9 @@ class EulerToRotation(NodeBuilder):
 
 
 class FindInString(NodeBuilder):
-    """Find the number of times a given string occurs in another string and the position of the first match"""
+    """
+    Find the number of times a given string occurs in another string and the position of the first match
+    """
 
     _bl_idname = "FunctionNodeFindInString"
     node: bpy.types.FunctionNodeFindInString
@@ -797,7 +850,9 @@ class FindInString(NodeBuilder):
 
 
 class FloatCurve(NodeBuilder):
-    """Map an input float to a curve and outputs a float value"""
+    """
+    Map an input float to a curve and outputs a float value
+    """
 
     _bl_idname = "ShaderNodeFloatCurve"
     node: bpy.types.ShaderNodeFloatCurve
@@ -829,7 +884,9 @@ class FloatCurve(NodeBuilder):
 
 
 class FloatToInteger(NodeBuilder):
-    """Convert the given floating-point number to an integer, with a choice of methods"""
+    """
+    Convert the given floating-point number to an integer, with a choice of methods
+    """
 
     _bl_idname = "FunctionNodeFloatToInt"
     node: bpy.types.FunctionNodeFloatToInt
@@ -865,7 +922,9 @@ class FloatToInteger(NodeBuilder):
 
 
 class HashValue(NodeBuilder):
-    """Generate a randomized integer using the given input value as a seed"""
+    """
+    Generate a randomized integer using the given input value as a seed
+    """
 
     _bl_idname = "FunctionNodeHashValue"
     node: bpy.types.FunctionNodeHashValue
@@ -965,7 +1024,9 @@ class HashValue(NodeBuilder):
 
 
 class IndexOfNearest(NodeBuilder):
-    """Find the nearest element in a group. Similar to the "Sample Nearest" node"""
+    """
+    Find the nearest element in a group. Similar to the "Sample Nearest" node
+    """
 
     _bl_idname = "GeometryNodeIndexOfNearest"
     node: bpy.types.GeometryNodeIndexOfNearest
@@ -1002,7 +1063,9 @@ class IndexOfNearest(NodeBuilder):
 
 
 class IntegerMath(NodeBuilder):
-    """Perform various math operations on the given integer inputs"""
+    """
+    Perform various math operations on the given integer inputs
+    """
 
     _bl_idname = "FunctionNodeIntegerMath"
     node: bpy.types.FunctionNodeIntegerMath
@@ -1067,6 +1130,21 @@ class IntegerMath(NodeBuilder):
         """Create Integer Math with operation 'Divide'."""
         return cls(operation="DIVIDE", value=value, value_001=value_001)
 
+    @classmethod
+    def multiply_add(
+        cls,
+        value: TYPE_INPUT_INT = 0,
+        value_001: TYPE_INPUT_INT = 0,
+        value_002: TYPE_INPUT_INT = 0,
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Multiply Add'."""
+        return cls(
+            operation="MULTIPLY_ADD",
+            value=value,
+            value_001=value_001,
+            value_002=value_002,
+        )
+
     @classmethod
     def absolute(cls, value: TYPE_INPUT_INT = 0) -> "IntegerMath":
         """Create Integer Math with operation 'Absolute'."""
@@ -1103,6 +1181,34 @@ class IntegerMath(NodeBuilder):
         """Create Integer Math with operation 'Sign'."""
         return cls(operation="SIGN", value=value)
 
+    @classmethod
+    def divide_round(
+        cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Divide Round'."""
+        return cls(operation="DIVIDE_ROUND", value=value, value_001=value_001)
+
+    @classmethod
+    def divide_floor(
+        cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Divide Floor'."""
+        return cls(operation="DIVIDE_FLOOR", value=value, value_001=value_001)
+
+    @classmethod
+    def divide_ceiling(
+        cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Divide Ceiling'."""
+        return cls(operation="DIVIDE_CEIL", value=value, value_001=value_001)
+
+    @classmethod
+    def floored_modulo(
+        cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Floored Modulo'."""
+        return cls(operation="FLOORED_MODULO", value=value, value_001=value_001)
+
     @classmethod
     def modulo(
         cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
@@ -1110,6 +1216,20 @@ class IntegerMath(NodeBuilder):
         """Create Integer Math with operation 'Modulo'."""
         return cls(operation="MODULO", value=value, value_001=value_001)
 
+    @classmethod
+    def greatest_common_divisor(
+        cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Greatest Common Divisor'."""
+        return cls(operation="GCD", value=value, value_001=value_001)
+
+    @classmethod
+    def least_common_multiple(
+        cls, value: TYPE_INPUT_INT = 0, value_001: TYPE_INPUT_INT = 0
+    ) -> "IntegerMath":
+        """Create Integer Math with operation 'Least Common Multiple'."""
+        return cls(operation="LCM", value=value, value_001=value_001)
+
     @property
     def i_value(self) -> SocketLinker:
         """Input socket: Value"""
@@ -1183,7 +1303,9 @@ class IntegerMath(NodeBuilder):
 
 
 class InvertMatrix(NodeBuilder):
-    """Compute the inverse of the given matrix, if one exists"""
+    """
+    Compute the inverse of the given matrix, if one exists
+    """
 
     _bl_idname = "FunctionNodeInvertMatrix"
     node: bpy.types.FunctionNodeInvertMatrix
@@ -1211,7 +1333,9 @@ class InvertMatrix(NodeBuilder):
 
 
 class InvertRotation(NodeBuilder):
-    """Compute the inverse of the given rotation"""
+    """
+    Compute the inverse of the given rotation
+    """
 
     _bl_idname = "FunctionNodeInvertRotation"
     node: bpy.types.FunctionNodeInvertRotation
@@ -1234,7 +1358,9 @@ class InvertRotation(NodeBuilder):
 
 
 class JoinBundle(NodeBuilder):
-    """Join multiple bundles together"""
+    """
+    Join multiple bundles together
+    """
 
     _bl_idname = "NodeJoinBundle"
     node: bpy.types.Node
@@ -1257,7 +1383,9 @@ class JoinBundle(NodeBuilder):
 
 
 class MapRange(NodeBuilder):
-    """Remap a value from a range to a target range"""
+    """
+    Remap a value from a range to a target range
+    """
 
     _bl_idname = "ShaderNodeMapRange"
     node: bpy.types.ShaderNodeMapRange
@@ -1441,7 +1569,9 @@ class MapRange(NodeBuilder):
 
 
 class MatchString(NodeBuilder):
-    """Check if a given string exists within another string"""
+    """
+    Check if a given string exists within another string
+    """
 
     _bl_idname = "FunctionNodeMatchString"
     node: bpy.types.FunctionNodeMatchString
@@ -1479,7 +1609,9 @@ class MatchString(NodeBuilder):
 
 
 class Math(NodeBuilder):
-    """Perform math operations"""
+    """
+    Perform math operations
+    """
 
     _bl_idname = "ShaderNodeMath"
     node: bpy.types.ShaderNodeMath
@@ -1569,6 +1701,21 @@ class Math(NodeBuilder):
         """Create Math with operation 'Divide'."""
         return cls(operation="DIVIDE", value=value, value_001=value_001)
 
+    @classmethod
+    def multiply_add(
+        cls,
+        value: TYPE_INPUT_VALUE = 0.5,
+        value_001: TYPE_INPUT_VALUE = 0.5,
+        value_002: TYPE_INPUT_VALUE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'Multiply Add'."""
+        return cls(
+            operation="MULTIPLY_ADD",
+            value=value,
+            value_001=value_001,
+            value_002=value_002,
+        )
+
     @classmethod
     def power(
         cls, value: TYPE_INPUT_VALUE = 0.5, value_001: TYPE_INPUT_VALUE = 0.5
@@ -1583,6 +1730,16 @@ class Math(NodeBuilder):
         """Create Math with operation 'Logarithm'."""
         return cls(operation="LOGARITHM", value=value, value_001=value_001)
 
+    @classmethod
+    def square_root(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'Square Root'."""
+        return cls(operation="SQRT", value=value)
+
+    @classmethod
+    def inverse_square_root(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'Inverse Square Root'."""
+        return cls(operation="INVERSE_SQRT", value=value)
+
     @classmethod
     def absolute(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
         """Create Math with operation 'Absolute'."""
@@ -1607,6 +1764,20 @@ class Math(NodeBuilder):
         """Create Math with operation 'Maximum'."""
         return cls(operation="MAXIMUM", value=value, value_001=value_001)
 
+    @classmethod
+    def less_than(
+        cls, value: TYPE_INPUT_VALUE = 0.5, value_001: TYPE_INPUT_VALUE = 0.5
+    ) -> "Math":
+        """Create Math with operation 'Less Than'."""
+        return cls(operation="LESS_THAN", value=value, value_001=value_001)
+
+    @classmethod
+    def greater_than(
+        cls, value: TYPE_INPUT_VALUE = 0.5, value_001: TYPE_INPUT_VALUE = 0.5
+    ) -> "Math":
+        """Create Math with operation 'Greater Than'."""
+        return cls(operation="GREATER_THAN", value=value, value_001=value_001)
+
     @classmethod
     def sign(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
         """Create Math with operation 'Sign'."""
@@ -1624,6 +1795,36 @@ class Math(NodeBuilder):
             operation="COMPARE", value=value, value_001=value_001, value_002=value_002
         )
 
+    @classmethod
+    def smooth_minimum(
+        cls,
+        value: TYPE_INPUT_VALUE = 0.5,
+        value_001: TYPE_INPUT_VALUE = 0.5,
+        value_002: TYPE_INPUT_VALUE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'Smooth Minimum'."""
+        return cls(
+            operation="SMOOTH_MIN",
+            value=value,
+            value_001=value_001,
+            value_002=value_002,
+        )
+
+    @classmethod
+    def smooth_maximum(
+        cls,
+        value: TYPE_INPUT_VALUE = 0.5,
+        value_001: TYPE_INPUT_VALUE = 0.5,
+        value_002: TYPE_INPUT_VALUE = 0.5,
+    ) -> "Math":
+        """Create Math with operation 'Smooth Maximum'."""
+        return cls(
+            operation="SMOOTH_MAX",
+            value=value,
+            value_001=value_001,
+            value_002=value_002,
+        )
+
     @classmethod
     def round(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
         """Create Math with operation 'Round'."""
@@ -1649,6 +1850,20 @@ class Math(NodeBuilder):
         """Create Math with operation 'Fraction'."""
         return cls(operation="FRACT", value=value)
 
+    @classmethod
+    def truncated_modulo(
+        cls, value: TYPE_INPUT_VALUE = 0.5, value_001: TYPE_INPUT_VALUE = 0.5
+    ) -> "Math":
+        """Create Math with operation 'Truncated Modulo'."""
+        return cls(operation="MODULO", value=value, value_001=value_001)
+
+    @classmethod
+    def floored_modulo(
+        cls, value: TYPE_INPUT_VALUE = 0.5, value_001: TYPE_INPUT_VALUE = 0.5
+    ) -> "Math":
+        """Create Math with operation 'Floored Modulo'."""
+        return cls(operation="FLOORED_MODULO", value=value, value_001=value_001)
+
     @classmethod
     def wrap(
         cls,
@@ -1668,6 +1883,13 @@ class Math(NodeBuilder):
         """Create Math with operation 'Snap'."""
         return cls(operation="SNAP", value=value, value_001=value_001)
 
+    @classmethod
+    def ping_pong(
+        cls, value: TYPE_INPUT_VALUE = 0.5, value_001: TYPE_INPUT_VALUE = 0.5
+    ) -> "Math":
+        """Create Math with operation 'Ping-Pong'."""
+        return cls(operation="PINGPONG", value=value, value_001=value_001)
+
     @classmethod
     def sine(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
         """Create Math with operation 'Sine'."""
@@ -1705,6 +1927,31 @@ class Math(NodeBuilder):
         """Create Math with operation 'Arctan2'."""
         return cls(operation="ARCTAN2", value=value, value_001=value_001)
 
+    @classmethod
+    def hyperbolic_sine(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'Hyperbolic Sine'."""
+        return cls(operation="SINH", value=value)
+
+    @classmethod
+    def hyperbolic_cosine(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'Hyperbolic Cosine'."""
+        return cls(operation="COSH", value=value)
+
+    @classmethod
+    def hyperbolic_tangent(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'Hyperbolic Tangent'."""
+        return cls(operation="TANH", value=value)
+
+    @classmethod
+    def to_radians(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'To Radians'."""
+        return cls(operation="RADIANS", value=value)
+
+    @classmethod
+    def to_degrees(cls, value: TYPE_INPUT_VALUE = 0.5) -> "Math":
+        """Create Math with operation 'To Degrees'."""
+        return cls(operation="DEGREES", value=value)
+
     @property
     def i_value(self) -> SocketLinker:
         """Input socket: Value"""
@@ -1832,7 +2079,9 @@ class Math(NodeBuilder):
 
 
 class MatrixDeterminant(NodeBuilder):
-    """Compute the determinant of the given matrix"""
+    """
+    Compute the determinant of the given matrix
+    """
 
     _bl_idname = "FunctionNodeMatrixDeterminant"
     node: bpy.types.FunctionNodeMatrixDeterminant
@@ -1855,7 +2104,9 @@ class MatrixDeterminant(NodeBuilder):
 
 
 class Mix(NodeBuilder):
-    """Mix values by a factor"""
+    """
+    Mix values by a factor
+    """
 
     _bl_idname = "ShaderNodeMix"
     node: bpy.types.ShaderNodeMix
@@ -2123,7 +2374,9 @@ class Mix(NodeBuilder):
 
 
 class MultiplyMatrices(NodeBuilder):
-    """Perform a matrix multiplication on two input matrices"""
+    """
+    Perform a matrix multiplication on two input matrices
+    """
 
     _bl_idname = "FunctionNodeMatrixMultiply"
     node: bpy.types.FunctionNodeMatrixMultiply
@@ -2155,7 +2408,9 @@ class MultiplyMatrices(NodeBuilder):
 
 
 class PackUVIslands(NodeBuilder):
-    """Scale islands of a UV map and move them so they fill the UV space as much as possible"""
+    """
+    Scale islands of a UV map and move them so they fill the UV space as much as possible
+    """
 
     _bl_idname = "GeometryNodeUVPackIslands"
     node: bpy.types.GeometryNodeUVPackIslands
@@ -2211,7 +2466,9 @@ class PackUVIslands(NodeBuilder):
 
 
 class ProjectPoint(NodeBuilder):
-    """Project a point using a matrix, using location, rotation, scale, and perspective divide"""
+    """
+    Project a point using a matrix, using location, rotation, scale, and perspective divide
+    """
 
     _bl_idname = "FunctionNodeProjectPoint"
     node: bpy.types.FunctionNodeProjectPoint
@@ -2243,7 +2500,9 @@ class ProjectPoint(NodeBuilder):
 
 
 class QuaternionToRotation(NodeBuilder):
-    """Build a rotation from quaternion components"""
+    """
+    Build a rotation from quaternion components
+    """
 
     _bl_idname = "FunctionNodeQuaternionToRotation"
     node: bpy.types.FunctionNodeQuaternionToRotation
@@ -2287,7 +2546,9 @@ class QuaternionToRotation(NodeBuilder):
 
 
 class RandomValue(NodeBuilder):
-    """Output a randomized value"""
+    """
+    Output a randomized value
+    """
 
     _bl_idname = "FunctionNodeRandomValue"
     node: bpy.types.FunctionNodeRandomValue
@@ -2439,7 +2700,9 @@ class RandomValue(NodeBuilder):
 
 
 class ReplaceString(NodeBuilder):
-    """Replace a given string segment with another"""
+    """
+    Replace a given string segment with another
+    """
 
     _bl_idname = "FunctionNodeReplaceString"
     node: bpy.types.FunctionNodeReplaceString
@@ -2477,7 +2740,9 @@ class ReplaceString(NodeBuilder):
 
 
 class RotateEuler(NodeBuilder):
-    """Apply a secondary Euler rotation to a given Euler rotation"""
+    """
+    Apply a secondary Euler rotation to a given Euler rotation
+    """
 
     _bl_idname = "FunctionNodeRotateEuler"
     node: bpy.types.FunctionNodeRotateEuler
@@ -2546,7 +2811,9 @@ class RotateEuler(NodeBuilder):
 
 
 class RotateRotation(NodeBuilder):
-    """Apply a secondary rotation to a given rotation value"""
+    """
+    Apply a secondary rotation to a given rotation value
+    """
 
     _bl_idname = "FunctionNodeRotateRotation"
     node: bpy.types.FunctionNodeRotateRotation
@@ -2588,7 +2855,9 @@ class RotateRotation(NodeBuilder):
 
 
 class RotateVector(NodeBuilder):
-    """Apply a rotation to a given vector"""
+    """
+    Apply a rotation to a given vector
+    """
 
     _bl_idname = "FunctionNodeRotateVector"
     node: bpy.types.FunctionNodeRotateVector
@@ -2620,7 +2889,9 @@ class RotateVector(NodeBuilder):
 
 
 class RotationToAxisAngle(NodeBuilder):
-    """Convert a rotation to axis angle components"""
+    """
+    Convert a rotation to axis angle components
+    """
 
     _bl_idname = "FunctionNodeRotationToAxisAngle"
     node: bpy.types.FunctionNodeRotationToAxisAngle
@@ -2648,7 +2919,9 @@ class RotationToAxisAngle(NodeBuilder):
 
 
 class RotationToEuler(NodeBuilder):
-    """Convert a standard rotation value to an Euler rotation"""
+    """
+    Convert a standard rotation value to an Euler rotation
+    """
 
     _bl_idname = "FunctionNodeRotationToEuler"
     node: bpy.types.FunctionNodeRotationToEuler
@@ -2671,7 +2944,9 @@ class RotationToEuler(NodeBuilder):
 
 
 class RotationToQuaternion(NodeBuilder):
-    """Retrieve the quaternion components representing a rotation"""
+    """
+    Retrieve the quaternion components representing a rotation
+    """
 
     _bl_idname = "FunctionNodeRotationToQuaternion"
     node: bpy.types.FunctionNodeRotationToQuaternion
@@ -2709,7 +2984,9 @@ class RotationToQuaternion(NodeBuilder):
 
 
 class SeparateBundle(NodeBuilder):
-    """Split a bundle into multiple sockets."""
+    """
+    Split a bundle into multiple sockets.
+    """
 
     _bl_idname = "NodeSeparateBundle"
     node: bpy.types.Node
@@ -2740,7 +3017,9 @@ class SeparateBundle(NodeBuilder):
 
 
 class SeparateColor(NodeBuilder):
-    """Split a color into separate channels, based on a particular color model"""
+    """
+    Split a color into separate channels, based on a particular color model
+    """
 
     _bl_idname = "FunctionNodeSeparateColor"
     node: bpy.types.FunctionNodeSeparateColor
@@ -2791,7 +3070,9 @@ class SeparateColor(NodeBuilder):
 
 
 class SeparateMatrix(NodeBuilder):
-    """Split a 4x4 matrix into its individual values"""
+    """
+    Split a 4x4 matrix into its individual values
+    """
 
     _bl_idname = "FunctionNodeSeparateMatrix"
     node: bpy.types.FunctionNodeSeparateMatrix
@@ -2889,7 +3170,9 @@ class SeparateMatrix(NodeBuilder):
 
 
 class SeparateTransform(NodeBuilder):
-    """Split a transformation matrix into a translation vector, a rotation, and a scale vector"""
+    """
+    Split a transformation matrix into a translation vector, a rotation, and a scale vector
+    """
 
     _bl_idname = "FunctionNodeSeparateTransform"
     node: bpy.types.FunctionNodeSeparateTransform
@@ -2922,7 +3205,9 @@ class SeparateTransform(NodeBuilder):
 
 
 class SeparateXYZ(NodeBuilder):
-    """Split a vector into its X, Y, and Z components"""
+    """
+    Split a vector into its X, Y, and Z components
+    """
 
     _bl_idname = "ShaderNodeSeparateXYZ"
     node: bpy.types.ShaderNodeSeparateXYZ
@@ -2955,7 +3240,9 @@ class SeparateXYZ(NodeBuilder):
 
 
 class SliceString(NodeBuilder):
-    """Extract a string segment from a larger string"""
+    """
+    Extract a string segment from a larger string
+    """
 
     _bl_idname = "FunctionNodeSliceString"
     node: bpy.types.FunctionNodeSliceString
@@ -2993,7 +3280,9 @@ class SliceString(NodeBuilder):
 
 
 class StringLength(NodeBuilder):
-    """Output the number of characters in the given string"""
+    """
+    Output the number of characters in the given string
+    """
 
     _bl_idname = "FunctionNodeStringLength"
     node: bpy.types.FunctionNodeStringLength
@@ -3016,7 +3305,9 @@ class StringLength(NodeBuilder):
 
 
 class StringToValue(NodeBuilder):
-    """Derive a numeric value from a given string representation"""
+    """
+    Derive a numeric value from a given string representation
+    """
 
     _bl_idname = "FunctionNodeStringToValue"
     node: bpy.types.FunctionNodeStringToValue
@@ -3067,7 +3358,9 @@ class StringToValue(NodeBuilder):
 
 
 class Switch(NodeBuilder):
-    """Switch between two inputs"""
+    """
+    Switch between two inputs
+    """
 
     _bl_idname = "GeometryNodeSwitch"
     node: bpy.types.GeometryNodeSwitch
@@ -3331,7 +3624,9 @@ class Switch(NodeBuilder):
 
 
 class TransformDirection(NodeBuilder):
-    """Apply a transformation matrix (excluding translation) to the given vector"""
+    """
+    Apply a transformation matrix (excluding translation) to the given vector
+    """
 
     _bl_idname = "FunctionNodeTransformDirection"
     node: bpy.types.FunctionNodeTransformDirection
@@ -3363,7 +3658,9 @@ class TransformDirection(NodeBuilder):
 
 
 class TransformPoint(NodeBuilder):
-    """Apply a transformation matrix to the given vector"""
+    """
+    Apply a transformation matrix to the given vector
+    """
 
     _bl_idname = "FunctionNodeTransformPoint"
     node: bpy.types.FunctionNodeTransformPoint
@@ -3395,7 +3692,9 @@ class TransformPoint(NodeBuilder):
 
 
 class TransposeMatrix(NodeBuilder):
-    """Flip a matrix over its diagonal, turning columns into rows and vice-versa"""
+    """
+    Flip a matrix over its diagonal, turning columns into rows and vice-versa
+    """
 
     _bl_idname = "FunctionNodeTransposeMatrix"
     node: bpy.types.FunctionNodeTransposeMatrix
@@ -3418,7 +3717,9 @@ class TransposeMatrix(NodeBuilder):
 
 
 class UVUnwrap(NodeBuilder):
-    """Generate a UV map based on seam edges"""
+    """
+    Generate a UV map based on seam edges
+    """
 
     _bl_idname = "GeometryNodeUVUnwrap"
     node: bpy.types.GeometryNodeUVUnwrap
@@ -3474,7 +3775,9 @@ class UVUnwrap(NodeBuilder):
 
 
 class ValueToString(NodeBuilder):
-    """Generate a string representation of the given input value"""
+    """
+    Generate a string representation of the given input value
+    """
 
     _bl_idname = "FunctionNodeValueToString"
     node: bpy.types.FunctionNodeValueToString