procfunc 0.33.1__tar.gz → 0.34.0__tar.gz

{procfunc-0.33.1/src/procfunc.egg-info → procfunc-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.33.1
+Version: 0.34.0
 Summary: Function-Oriented Abstractions for Procedural 3D Generation in Python
 License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://github.com/princeton-vl/procfunc
@@ -16,6 +16,8 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-xdist; extra == "dev"
 Requires-Dist: ruff<0.16,>=0.15; extra == "dev"
 Requires-Dist: ty; extra == "dev"
+Requires-Dist: imageio; extra == "dev"
+Requires-Dist: matplotlib; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"

{procfunc-0.33.1 → procfunc-0.34.0}/pyproject.toml

@@ -27,7 +27,9 @@ dev = [
     "pytest",
     "pytest-xdist",
     "ruff>=0.15,<0.16",
-    "ty"
+    "ty",
+    "imageio",
+    "matplotlib",
 ]
 docs = [
     "sphinx",

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/__init__.py

@@ -2,7 +2,7 @@
 # ensure this gets imported first so that mathutils etc is available even if later modules dont import bpy
 import bpy
 
-__version__ = "0.33.1"
+__version__ = "0.34.0"
 
 from numpy.random import Generator as RNG
 

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/color.py

@@ -10,6 +10,8 @@ def hsv_color(
     saturation: float | None = None,
     value: float | None = None,
 ) -> t.Color:
+    if hsv is None and (hue is None or saturation is None or value is None):
+        raise ValueError("provide hsv=... or all of hue/saturation/value")
     color = t.Color()
     if hsv is not None:
         color.hsv = hsv
@@ -27,12 +29,9 @@ def rgb_color(
     b: float | None = None,
     rgb: np.ndarray | None = None,
 ) -> t.Color:
-    color = t.Color()
-    if rgb is not None:
-        color.r, color.g, color.b = rgb
-    else:
-        color.r, color.g, color.b = r, g, b
-    return color
+    if rgb is None and (r is None or g is None or b is None):
+        raise ValueError("provide rgb=... or all of r/g/b")
+    return t.Color(rgb if rgb is not None else (r, g, b))
 
 
 def _srgb_to_linearrgb(c):
@@ -44,14 +43,12 @@ def _srgb_to_linearrgb(c):
         return ((c + 0.055) / 1.055) ** 2.4
 
 
-def _hex_to_rgb(h: int, alpha: float = 1):
+def _hex_to_rgb(h: int):
     r = (h & 0xFF0000) >> 16
     g = (h & 0x00FF00) >> 8
     b = h & 0x0000FF
     return tuple([_srgb_to_linearrgb(c / 0xFF) for c in (r, g, b)])
 
 
-def hex_color(h: int, alpha: float = 1):
-    c = t.Color()
-    c.r, c.g, c.b = _hex_to_rgb(h, alpha)
-    return c
+def hex_color(h: int) -> t.Color:
+    return t.Color(_hex_to_rgb(h))

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/compute_graph/__init__.py

@@ -45,7 +45,6 @@ __all__ = [
     "LiteralConstant",
     "graph_nodes_equal",
     "transform_compute_graph",
-    "transform_nodetree",
     "traverse_breadth_first",
     "traverse_depth_first",
     "traverse_depth_first_node",

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/compute_graph/util.py

@@ -3,10 +3,21 @@ import logging
 from collections import defaultdict, deque
 from typing import Any, Callable, Generator, Literal, TypeVar
 
+import numpy as np
+
 from procfunc.util import pytree
 
 from .compute_graph import ComputeGraph
-from .node import Node, SubgraphCallNode
+from .node import (
+    ConstantNode,
+    FunctionCallNode,
+    GetAttributeNode,
+    InputPlaceholderNode,
+    MethodCallNode,
+    Node,
+    ProceduralNode,
+    SubgraphCallNode,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -40,6 +51,7 @@ def traverse_breadth_first(
 
     visited = set()
     frontier = deque((None, name, node) for name, node in graph.outputs.items())
+    visited.update(id(node) for _, _, node in frontier)
     # logger.debug(f"{traverse_breadth_first.__name__} {graph.name} {len(frontier)=}")
 
     def res(parent, name, child):
@@ -61,10 +73,6 @@ def traverse_breadth_first(
         if not isinstance(node, Node):
             continue
 
-        if id(node) in visited:
-            continue
-        visited.add(id(node))
-
         yield res(parent, name, node)
 
         children = list(pytree.PyTree(node.args).items()) + list(
@@ -75,6 +83,7 @@ def traverse_breadth_first(
                 continue
             if id(arg) in visited:
                 continue
+            visited.add(id(arg))
             frontier.append((node, key, arg))
 
 
@@ -201,22 +210,95 @@ def usages_per_node(
     return dict(usages)
 
 
-def graph_nodes_equal(graph1: ComputeGraph, graph2: ComputeGraph) -> bool:
-    nodes1 = list(traverse_depth_first(graph1))
-    nodes2 = list(traverse_depth_first(graph2))
-    if len(nodes1) != len(nodes2):
+def _value_equal(a: Any, b: Any) -> bool:
+    """Array-safe equality for non-node values (constants, attrs, defaults)."""
+    if a is b:
+        return True
+    if isinstance(a, np.ndarray) or isinstance(b, np.ndarray):
+        return np.array_equal(a, b)
+    if isinstance(a, dict) and isinstance(b, dict):
+        return a.keys() == b.keys() and all(_value_equal(a[k], b[k]) for k in a)
+    if isinstance(a, (list, tuple)) and isinstance(b, (list, tuple)):
+        return (
+            type(a) is type(b)
+            and len(a) == len(b)
+            and all(_value_equal(x, y) for x, y in zip(a, b))
+        )
+    try:
+        return bool(a == b)
+    except (ValueError, TypeError):
+        return False
+
+
+def _args_equal(a: Any, b: Any, memo: dict[tuple[int, int], bool]) -> bool:
+    """Structural equality of an args/kwargs tree: same container shape, with
+    node-valued leaves compared recursively and other leaves by value."""
+    tree_a = pytree.PyTree(a)
+    tree_b = pytree.PyTree(b)
+    if tree_a.spec != tree_b.spec:
         return False
-    for node1, node2 in zip(nodes1, nodes2):
-        if type(node1) is not type(node2):
+    for leaf_a, leaf_b in zip(tree_a.values(), tree_b.values()):
+        a_is_node = isinstance(leaf_a, Node)
+        b_is_node = isinstance(leaf_b, Node)
+        if a_is_node != b_is_node:
             return False
-        if isinstance(node1, SubgraphCallNode):
-            if not graph_nodes_equal(node1.subgraph, node2.subgraph):
+        if a_is_node:
+            if not _nodes_equal(leaf_a, leaf_b, memo):
                 return False
-        elif node1.args != node2.args or node1.kwargs != node2.kwargs:
+        elif not _value_equal(leaf_a, leaf_b):
             return False
     return True
 
 
+def _nodes_equal(node1: Node, node2: Node, memo: dict[tuple[int, int], bool]) -> bool:
+    if node1 is node2:
+        return True
+    if type(node1) is not type(node2):
+        return False
+
+    key = (id(node1), id(node2))
+    cached = memo.get(key)
+    if cached is not None:
+        return cached
+    memo[key] = True  # optimistic, breaks cycles in shared DAGs
+
+    result = True
+    if isinstance(node1, SubgraphCallNode):
+        result = graph_nodes_equal(node1.subgraph, node2.subgraph)
+    if result and isinstance(node1, FunctionCallNode):
+        result = node1.func is node2.func
+    if result and isinstance(node1, MethodCallNode):
+        result = node1.method_name == node2.method_name
+    if result and isinstance(node1, GetAttributeNode):
+        result = node1.attribute_name == node2.attribute_name
+    if result and isinstance(node1, ProceduralNode):
+        result = node1.node_type == node2.node_type and _value_equal(
+            node1.attrs, node2.attrs
+        )
+    if result and isinstance(node1, ConstantNode):
+        result = _value_equal(node1.value, node2.value)
+    if result and isinstance(node1, InputPlaceholderNode):
+        result = node1.input_name == node2.input_name and _value_equal(
+            node1.default_value, node2.default_value
+        )
+    if result:
+        result = _args_equal(node1.args, node2.args, memo) and _args_equal(
+            node1.kwargs, node2.kwargs, memo
+        )
+
+    memo[key] = result
+    return result
+
+
+def graph_nodes_equal(graph1: ComputeGraph, graph2: ComputeGraph) -> bool:
+    nodes1 = list(traverse_depth_first(graph1))
+    nodes2 = list(traverse_depth_first(graph2))
+    if len(nodes1) != len(nodes2):
+        return False
+    memo: dict[tuple[int, int], bool] = {}
+    return all(_nodes_equal(node1, node2, memo) for node1, node2 in zip(nodes1, nodes2))
+
+
 def transform_nodetree(
     root: Node,
     transform_fn: Callable[[Node], Any],

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/context.py

@@ -13,24 +13,6 @@ class ProcfuncContext:
     num_cpu_cores: int
     current_trace_level: int | None  # compared against to TraceLevel int values
 
-    warn_mode_avoid_normal_bump: Literal["ignore", "warn", "throw"]
-    """
-    Set to 'throw' for strict usage. Using a normal map / bump map / BSDF vector input _can_ be useful,
-    but its always better to do it via the Displacement output of the shader (so that it at least can also be done as displacement)
-    """
-
-    warn_mode_avoid_implicit_vector: Literal["ignore", "warn", "throw"]
-    """
-    Set to 'throw' to force the user to specify exactly what vector to sample.
-    This prevents materials from being incorrect when on a moving object, or ignoring uv coordinates
-    """
-
-    warn_mode_avoid_io_nodes: Literal["ignore", "warn", "throw"]
-    """
-    Set to 'throw' to prevent floating Value Vector Color nodes, or strange output nodes like AOV in shader
-    Intent is to force nodegroups to be more functional - all inputs and outputs go through nodegroup interface
-    """
-
     warn_mode_empty_geonodes: Literal["ignore", "warn", "throw"]
     """
     Controls behavior when a geometry node graph produces no mesh geometry (e.g. unconnected inputs).
@@ -44,16 +26,10 @@ class ProcfuncContext:
 
     def set_strict(self):
         """Set all warning modes to 'throw'"""
-        self.warn_mode_avoid_normal_bump = "throw"
-        self.warn_mode_avoid_implicit_vector = "throw"
-        self.warn_mode_avoid_io_nodes = "throw"
         self.warn_mode_empty_geonodes = "throw"
 
     def set_warn(self):
         """Set all warning modes to 'warn'"""
-        self.warn_mode_avoid_normal_bump = "warn"
-        self.warn_mode_avoid_implicit_vector = "warn"
-        self.warn_mode_avoid_io_nodes = "warn"
         self.warn_mode_empty_geonodes = "warn"
 
 
@@ -61,27 +37,11 @@ class ProcfuncContext:
 
 warn_modes = ["ignore", "warn", "throw"]
 
-_warn_mode_avoid_normal_bump = os.environ.get(
-    "PROCFUNC_WARN_MODE_AVOID_NORMAL_BUMP", "ignore"
-)
-assert _warn_mode_avoid_normal_bump in warn_modes
-
-warn_mode_avoid_implicit_vector = os.environ.get(
-    "PROCFUNC_WARN_MODE_AVOID_IMPLICIT_VECTOR", "ignore"
-)
-assert warn_mode_avoid_implicit_vector in warn_modes
-
-warn_mode_avoid_io_nodes = os.environ.get("PROCFUNC_WARN_MODE_AVOID_IO_NODES", "ignore")
-assert warn_mode_avoid_io_nodes in warn_modes
-
 _warn_mode_empty_geonodes = os.environ.get("PROCFUNC_WARN_MODE_EMPTY_GEONODES", "warn")
 assert _warn_mode_empty_geonodes in warn_modes
 
 globals = ProcfuncContext(
     num_cpu_cores=int(os.environ.get("PROCFUNC_NUM_CPU_CORES", 0)),
-    warn_mode_avoid_normal_bump=_warn_mode_avoid_normal_bump,  # type: ignore[invalid-assignment]
-    warn_mode_avoid_implicit_vector=warn_mode_avoid_implicit_vector,  # type: ignore[invalid-assignment]
-    warn_mode_avoid_io_nodes=warn_mode_avoid_io_nodes,  # type: ignore[invalid-assignment]
     warn_mode_empty_geonodes=_warn_mode_empty_geonodes,  # type: ignore[invalid-assignment]
     current_trace_level=None,
 )

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/control/__init__.py

@@ -127,12 +127,9 @@ def choice(
 ) -> T:
     """
     Args:
-        rng: random number generator
-        weights: list of weights for each option - will be normalized to sum to 1 as a probability distribution
-        options: list of callables to choose from
-        chosen: if not None, use this value instead of choosing randomly. Cannot be traced, but may appear in the output of the tracer.
+        choice_rng: random number generator
+        choice_options: list of (value, weight) tuples; weights are normalized to a probability distribution
         chosen_idx: if not None, use this index instead of choosing randomly. Cannot be traced, but may appear in the output of the tracer.
-        **child_kwargs: keyword arguments to pass to the chosen callable
 
     TODO: this function should really take args and kwargs as tuple & dict, not via expansion
     but this requires our Node to handle cases with pytrees as inputs. Currently it would fail to execute the children if they are hidden in a pytree

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/nodes/color.py

@@ -39,7 +39,7 @@ def mix_rgb(
     clamp_factor: bool = True,
 ) -> nt.ProcNode[pt.Color]:
     """
-    Uses a Mix Node with datatype Color
+    Uses a Mix Shader Node with data_type='RGBA'.
 
     NOTE: separated from float/vector mix() due to extra arguments
 
@@ -80,7 +80,7 @@ def combine_rgb(
     blue: nt.SocketOrVal[float] = 0.0,
 ) -> nt.ProcNode[pt.Color]:
     """
-    Uses a CombineColor Shader Node.
+    Uses a CombineColor Shader Node in RGB mode.
 
     See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
     """
@@ -97,7 +97,7 @@ def combine_hsv(
     value: nt.SocketOrVal[float] = 0.0,
 ) -> nt.ProcNode[pt.Color]:
     """
-    Uses a CombineColor Shader Node.
+    Uses a CombineColor Shader Node in HSV mode.
 
     See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
     """
@@ -115,7 +115,7 @@ def combine_hsl(
     lightness: nt.SocketOrVal[float] = 0.0,
 ) -> nt.ProcNode[pt.Color]:
     """
-    Uses a CombineHSV Shader Node.
+    Uses a CombineColor Shader Node in HSL mode.
 
     See: https://docs.blender.org/manual/en/4.2/render/shader_nodes/converter/combine_color.html
     """

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/nodes/execute/construct_standard.py

@@ -320,26 +320,22 @@ def _construct_procnode_standard(
     for input_name, input_py in kwargs.items():
         input_result = input_results[input_name]
         if input_result is None:
-            # Strict-None policy: None means "leave disconnected" and is only
-            # allowed for sockets with no default_value attr at all (Geometry,
-            # Shader, Matrix, Virtual) - never rely on Blender's internal
-            # defaults, whose values may change across versions. A disabled or
-            # missing socket name is a binding bug and propagates as ValueError.
             to_socket = get_input_socket_to_connect_to(
                 bl_node_tree, bl_node, input_name, None
             )
-            # IMAGE default_value is a datablock pointer; None faithfully means "no image assigned"
             if (
                 to_socket.is_multi_input
                 or not hasattr(to_socket, "default_value")
-                or to_socket.type == "IMAGE"
+                or to_socket.hide_value
+                or to_socket.default_value is None
             ):
                 continue
             raise ValueError(
                 f"Node {bl_node.name!r} input {to_socket.name!r} (socket type "
                 f"{to_socket.type}) received None. Explicitly pass a value; None is "
-                f"only allowed for sockets with no default_value attribute "
-                f"(e.g. Geometry/Shader) or with a datablock pointer one (Image)."
+                f"only allowed for disconnected implicit-field sockets (hide_value), "
+                f"datablock pointers, or sockets with no default_value attribute "
+                f"(e.g. Geometry/Shader)."
             )
         to_socket = get_input_socket_to_connect_to(
             bl_node_tree, bl_node, input_name, input_result

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/nodes/execute/util.py

@@ -327,6 +327,8 @@ def assign_default_value(
             target_socket.default_value = t.Vector(input_val)
         case bni.NodeDataType.FLOAT:
             target_socket.default_value = float(input_val)
+        case bni.NodeDataType.INT:
+            target_socket.default_value = int(input_val)
         case bni.NodeDataType.FLOAT_MATRIX:
             # matrix values travel as numpy arrays in the compute graph;
             # coerce back to mathutils.Matrix for bpy

{procfunc-0.33.1 → procfunc-0.34.0}/src/procfunc/nodes/func.py

@@ -6,7 +6,6 @@ from procfunc.nodes import types as nt
 from procfunc.nodes.util.bindings_util import (
     ContextualNode,
     RuntimeResolveDataType,
-    raise_io_error,
 )
 from procfunc.nodes.util.bpy_node_info import NodeDataType
 
@@ -92,6 +91,7 @@ def boolean_or(
     a: nt.SocketOrVal[bool],
     b: nt.SocketOrVal[bool],
 ) -> nt.ProcNode[bool]:
+    """Uses a BooleanMath Function Node with operation='OR'."""
     return nt.ProcNode.from_nodetype(
         node_type="FunctionNodeBooleanMath",
         inputs={("Boolean", 0): a, ("Boolean", 1): b},
@@ -103,6 +103,7 @@ def boolean_and(
     a: nt.SocketOrVal[bool],
     b: nt.SocketOrVal[bool],
 ) -> nt.ProcNode[bool]:
+    """Uses a BooleanMath Function Node with operation='AND'."""
     return nt.ProcNode.from_nodetype(
         node_type="FunctionNodeBooleanMath",
         inputs={("Boolean", 0): a, ("Boolean", 1): b},
@@ -114,6 +115,7 @@ def boolean_xor(
     a: nt.SocketOrVal[bool],
     b: nt.SocketOrVal[bool],
 ) -> nt.ProcNode[bool]:
+    """Uses a BooleanMath Function Node with operation='XOR'."""
     return nt.ProcNode.from_nodetype(
         node_type="FunctionNodeBooleanMath",
         inputs={("Boolean", 0): a, ("Boolean", 1): b},
@@ -125,7 +127,7 @@ def boolean_not(
     a: nt.SocketOrVal[bool],
 ) -> nt.ProcNode[bool]:
     """
-    Uses a BooleanNot Function Node.
+    Uses a BooleanMath Function Node with operation='NOT'.
 
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/math/boolean_math.html
     """
@@ -275,6 +277,7 @@ def less_than(
     a: TCompareNumeric,
     b: TCompareNumeric,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with operation='LESS_THAN'."""
     return _compare(a, b, operation="LESS_THAN")
 
 
@@ -282,6 +285,7 @@ def less_equal(
     a: TCompareNumeric,
     b: TCompareNumeric,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with operation='LESS_EQUAL'."""
     return _compare(a, b, operation="LESS_EQUAL")
 
 
@@ -289,6 +293,7 @@ def greater_than(
     a: TCompareNumeric,
     b: TCompareNumeric,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with operation='GREATER_THAN'."""
     return _compare(a, b, operation="GREATER_THAN")
 
 
@@ -296,6 +301,7 @@ def greater_equal(
     a: TCompareNumeric,
     b: TCompareNumeric,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with operation='GREATER_EQUAL'."""
     return _compare(a, b, operation="GREATER_EQUAL")
 
 
@@ -311,6 +317,7 @@ def equal(
     b: TCompareEqual,
     epsilon: nt.SocketOrVal[float] = COMPARE_EPSILON_DEFAULT,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with operation='EQUAL'."""
     return _compare(a, b, epsilon, operation="EQUAL")
 
 
@@ -319,6 +326,7 @@ def not_equal(
     b: TCompareEqual,
     epsilon: nt.SocketOrVal[float] = COMPARE_EPSILON_DEFAULT,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with operation='NOT_EQUAL'."""
     return _compare(a, b, epsilon, operation="NOT_EQUAL")
 
 
@@ -332,6 +340,7 @@ def vector_elementwise_less_than(
     a: nt.SocketOrVal[pt.Vector],
     b: nt.SocketOrVal[pt.Vector],
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='VECTOR', mode='ELEMENT', operation='LESS_THAN'."""
     return _compare(a, b, operation="LESS_THAN", data_type=NodeDataType.FLOAT_VECTOR)
 
 
@@ -339,6 +348,7 @@ def vector_elementwise_less_equal(
     a: nt.SocketOrVal[pt.Vector],
     b: nt.SocketOrVal[pt.Vector],
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='VECTOR', mode='ELEMENT', operation='LESS_EQUAL'."""
     return _compare(a, b, operation="LESS_EQUAL", data_type=NodeDataType.FLOAT_VECTOR)
 
 
@@ -346,6 +356,7 @@ def vector_elementwise_greater_than(
     a: nt.SocketOrVal[pt.Vector],
     b: nt.SocketOrVal[pt.Vector],
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='VECTOR', mode='ELEMENT', operation='GREATER_THAN'."""
     return _compare(a, b, operation="GREATER_THAN", data_type=NodeDataType.FLOAT_VECTOR)
 
 
@@ -353,6 +364,7 @@ def vector_elementwise_greater_equal(
     a: nt.SocketOrVal[pt.Vector],
     b: nt.SocketOrVal[pt.Vector],
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='VECTOR', mode='ELEMENT', operation='GREATER_EQUAL'."""
     return _compare(
         a, b, operation="GREATER_EQUAL", data_type=NodeDataType.FLOAT_VECTOR
     )
@@ -363,6 +375,7 @@ def vector_elementwise_equal(
     b: nt.SocketOrVal[pt.Vector],
     epsilon: nt.SocketOrVal[float] = COMPARE_EPSILON_DEFAULT,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='VECTOR', mode='ELEMENT', operation='EQUAL'."""
     return _compare(
         a, b, epsilon, operation="EQUAL", data_type=NodeDataType.FLOAT_VECTOR
     )
@@ -373,6 +386,7 @@ def vector_elementwise_not_equal(
     b: nt.SocketOrVal[pt.Vector],
     epsilon: nt.SocketOrVal[float] = COMPARE_EPSILON_DEFAULT,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='VECTOR', mode='ELEMENT', operation='NOT_EQUAL'."""
     return _compare(
         a, b, epsilon, operation="NOT_EQUAL", data_type=NodeDataType.FLOAT_VECTOR
     )
@@ -383,6 +397,7 @@ def color_equal(
     b: nt.SocketOrVal[pt.Color],
     epsilon: nt.SocketOrVal[float] = COMPARE_EPSILON_DEFAULT,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='RGBA', operation='EQUAL'."""
     return _compare(a, b, epsilon, operation="EQUAL", data_type=NodeDataType.RGBA)
 
 
@@ -391,6 +406,7 @@ def color_not_equal(
     b: nt.SocketOrVal[pt.Color],
     epsilon: nt.SocketOrVal[float] = COMPARE_EPSILON_DEFAULT,
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='RGBA', operation='NOT_EQUAL'."""
     return _compare(a, b, epsilon, operation="NOT_EQUAL", data_type=NodeDataType.RGBA)
 
 
@@ -398,6 +414,7 @@ def color_brighter(
     a: nt.SocketOrVal[pt.Color],
     b: nt.SocketOrVal[pt.Color],
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='RGBA', operation='BRIGHTER'."""
     return _compare(a, b, operation="BRIGHTER", data_type=NodeDataType.RGBA)
 
 
@@ -405,6 +422,7 @@ def color_darker(
     a: nt.SocketOrVal[pt.Color],
     b: nt.SocketOrVal[pt.Color],
 ) -> nt.ProcNode[bool]:
+    """Uses a Compare Function Node with data_type='RGBA', operation='DARKER'."""
     return _compare(a, b, operation="DARKER", data_type=NodeDataType.RGBA)
 
 
@@ -447,8 +465,6 @@ def input_bool(boolean: bool = False) -> t.ProcNode[bool]:
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/boolean.html
     """
 
-    raise_io_error("input_bool", logger=logger)
-
     return t.ProcNode.from_nodetype(
         node_type="FunctionNodeInputBool",
         inputs={},
@@ -463,8 +479,6 @@ def input_color(value: tuple = (0.5, 0.5, 0.5, 1.0)) -> t.ProcNode[pt.Color]:
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/color.html
     """
 
-    raise_io_error("input_color", logger=logger)
-
     return t.ProcNode.from_nodetype(
         node_type="FunctionNodeInputColor",
         inputs={},
@@ -479,8 +493,6 @@ def input_int(integer: int = 0) -> t.ProcNode[int]:
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/integer.html
     """
 
-    raise_io_error("input_int", logger=logger)
-
     return t.ProcNode.from_nodetype(
         node_type="FunctionNodeInputInt",
         inputs={},
@@ -495,8 +507,6 @@ def input_rotation(rotation_euler: tuple = (0.0, 0.0, 0.0)) -> t.ProcNode[pt.Vec
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/rotation.html
     """
 
-    raise_io_error("input_rotation", logger=logger)
-
     return t.ProcNode.from_nodetype(
         node_type="FunctionNodeInputRotation",
         inputs={},
@@ -517,8 +527,6 @@ def input_special_characters() -> InputSpecialCharactersResult:
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/utilities/text/special_characters.html
     """
 
-    raise_io_error("input_special_characters", logger=logger)
-
     node = nt.ProcNode.from_nodetype(
         node_type="FunctionNodeInputSpecialCharacters",
         inputs={},
@@ -536,8 +544,6 @@ def input_string(string: str = "") -> nt.ProcNode[str]:
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/string.html
     """
 
-    raise_io_error("input_string", logger=logger)
-
     return nt.ProcNode.from_nodetype(
         node_type="FunctionNodeInputString",
         inputs={},
@@ -552,8 +558,6 @@ def input_vector(vector: tuple = (0.0, 0.0, 0.0)) -> nt.ProcNode[pt.Vector]:
     See: https://docs.blender.org/manual/en/4.2/modeling/geometry_nodes/input/constant/vector.html
     """
 
-    raise_io_error("input_vector", logger=logger)
-
     return nt.ProcNode.from_nodetype(
         node_type="FunctionNodeInputVector",
         inputs={},
@@ -693,7 +697,7 @@ def random_boolean(
     seed: nt.SocketOrVal[int] = 0,
 ) -> nt.ProcNode[bool]:
     """
-    Uses a RandomBoolean Function Node.
+    Uses a RandomValue Function Node with data_type='BOOLEAN'.
     """
     return nt.ProcNode.from_nodetype(
         node_type="FunctionNodeRandomValue",