procfunc 0.33.1__tar.gz → 0.35.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.33.1
+Version: 0.35.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.35.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.35.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.35.0"
 
 from numpy.random import Generator as RNG
 

{procfunc-0.33.1 → procfunc-0.35.0}/src/procfunc/codegen/codegen.py

@@ -1,3 +1,4 @@
+import ast
 import dataclasses
 import enum
 import inspect
@@ -5,7 +6,7 @@ import itertools
 import logging
 from collections import OrderedDict, defaultdict
 from pathlib import Path
-from typing import Any, Callable, Generator
+from typing import Any, Callable, Generator, get_type_hints
 
 import numpy as np
 
@@ -24,6 +25,30 @@ logger = logging.getLogger(__name__)
 
 INDENT = "    "
 
+# UnaryOp included since ** binds tighter than unary minus: -2.0 ** x == -(2.0 ** x)
+_PAREN_SENSITIVE_NODES = (ast.BinOp, ast.UnaryOp, ast.Compare, ast.BoolOp, ast.IfExp)
+
+
+def _has_enclosing_parens(expr: str) -> bool:
+    if not (expr.startswith("(") and expr.endswith(")")):
+        return False
+    depth = 0
+    for i, char in enumerate(expr):
+        depth += (char == "(") - (char == ")")
+        if depth == 0:
+            return i == len(expr) - 1
+    return False
+
+
+def _needs_parens(expr: str) -> bool:
+    if _has_enclosing_parens(expr):
+        return False
+    try:
+        parsed = ast.parse(expr, mode="eval")
+    except SyntaxError:
+        return " " in expr
+    return isinstance(parsed.body, _PAREN_SENSITIVE_NODES)
+
 
 def indent_lines(lines: list[str], indent: str = INDENT) -> list[str]:
     return [indent + line for line in lines]
@@ -52,7 +77,7 @@ def _repr_inp(
         expr = expr[0]
     assert isinstance(expr, str)
 
-    if " " in expr and extra_parens and expr[0] != "(" and expr[-1] != ")":
+    if extra_parens and _needs_parens(expr):
         return f"({expr})"
     else:
         return expr
@@ -146,7 +171,8 @@ def _repr_function_call(
             if not isinstance(target, cg.Node):
                 raise ValueError(f"Method call {node=} has non-node target {target=}")
             func = None
-            func_str = f"{_repr_inp(target, scope_expressions)}.{method_name}"
+            target_expr = _repr_inp(target, scope_expressions, extra_parens=True)
+            func_str = f"{target_expr}.{method_name}"
         case cg.SubgraphCallNode(subgraph=subgraph):
             func = None
             func_str = scope_expressions.get(id(subgraph))
@@ -176,6 +202,22 @@ def _repr_function_call(
         return [f"{func_str}({', '.join(arg_reprs)})"]
 
 
+# ==/!= only match Blender Compare for exact dtypes; float/vector stay epsilon-tolerant.
+_EPSILON_EQUALITY_TEMPLATES = frozenset(
+    OPERATOR_TEMPLATES[op] for op in (OperatorType.EQUAL, OperatorType.NOT_EQUAL)
+)
+
+
+def _is_exact_compare_operand(value: Any) -> bool:
+    if isinstance(value, (cg.Node, cg.Proxy)):
+        return False
+    if isinstance(value, str):
+        return True
+    if isinstance(value, bool):
+        return True
+    return isinstance(value, int) and not isinstance(value, float)
+
+
 def _operator_call_operands(
     node: cg.FunctionCallNode,
     template: str,
@@ -196,13 +238,21 @@ def _operator_call_operands(
     if any(name not in bound.arguments for name in operand_names):
         return None
 
+    operands = [bound.arguments[name] for name in operand_names]
+
+    # a default epsilon stays tolerant unlike exact ==/!=, so require exact operands
+    if template in _EPSILON_EQUALITY_TEMPLATES and not all(
+        _is_exact_compare_operand(v) for v in operands
+    ):
+        return None
+
     for name, value in bound.arguments.items():
         if name in operand_names:
             continue
         if not _kwarg_matches_default(sig, name, value):
             return None
 
-    return [bound.arguments[name] for name in operand_names]
+    return operands
 
 
 def _repr_operator_call(
@@ -244,7 +294,7 @@ def _codegen_for_node(
             else:
                 return _repr_function_call(node, scope_expressions)
         case cg.MethodCallNode() if node.method_name == "__getitem__":
-            callee_expr = _repr_inp(node.args[0], scope_expressions)
+            callee_expr = _repr_inp(node.args[0], scope_expressions, extra_parens=True)
             idx_expr = _repr_inp(node.args[1], scope_expressions)
             return [f"{callee_expr}[{idx_expr}]"]
         case cg.MethodCallNode():
@@ -280,7 +330,7 @@ def _codegen_graph_inputs(
 ) -> list[str]:
     args = sorted(
         list(graph.inputs.values()),
-        key=lambda x: x.kwargs.get("default_value", None) is not None,
+        key=lambda x: "default_value" in x.kwargs,
     )
 
     func_name = func_name or graph.name
@@ -305,8 +355,8 @@ def _codegen_graph_inputs(
             else f"{name}"
         )
 
-        if (default := node.kwargs.get("default_value")) is not None:
-            line += f" = {repr_value(default)}"
+        if "default_value" in node.kwargs:
+            line += f" = {repr_value(node.kwargs['default_value'])}"
 
         args_lines.append(line + ",")
 
@@ -315,18 +365,31 @@ def _codegen_graph_inputs(
     return [f"def {func_name}("] + indent_lines(args_lines) + [end_statement]
 
 
+def _namedtuple_field_type(node, annotation) -> str:
+    vt = node.metadata.get("known_value_type", None)
+    if vt is None:
+        vt = annotation
+    if vt is None:
+        return "Any"
+    try:
+        return repr_type(vt)
+    except Exception:
+        return "Any"
+
+
 def _codegen_namedtuple_def(outputs: pytree.PyTree):
     tupletype = outputs.toplevel_type()
+    try:
+        annotations = get_type_hints(tupletype)
+    except Exception:
+        annotations = getattr(tupletype, "__annotations__", {})
 
     type_lines = []
     for name, node in outputs.items():
         if node is None:
             continue
-        vt = node.metadata.get("known_value_type", None)
-        if vt is None:
-            type_lines.append(f"{name}: Any")
-        else:
-            type_lines.append(f"{name}: {repr_type(vt)}")
+        field_type = _namedtuple_field_type(node, annotations.get(name))
+        type_lines.append(f"{name}: {field_type}")
 
     return [f"class {tupletype.__name__}(NamedTuple):"] + indent_lines(type_lines)
 
@@ -840,7 +903,7 @@ def to_python(
     add_line_comments: bool = False,
 ) -> str:
     code_lines = []
-    code_lines.append("from typing import NamedTuple, Annotated")
+    code_lines.append("from typing import Any, NamedTuple, Annotated")
     code_lines.append("import numpy as np")
     code_lines.append("import bpy")
     # code_lines.append("import logging; logging.basicConfig(level=logging.DEBUG)")

{procfunc-0.33.1 → procfunc-0.35.0}/src/procfunc/codegen/repr.py

@@ -2,6 +2,7 @@ import dataclasses
 import enum
 import logging
 import math
+import types
 from pathlib import Path
 from typing import Any, Union, get_args, get_origin
 
@@ -20,12 +21,22 @@ def repr_type(x: Any) -> str:
     if isinstance(x, str):
         return x
 
-    if x.__name__ == "NoneType":
-        return "None"
-
     origin = get_origin(x)
     args = get_args(x)
 
+    if origin is Union or origin is types.UnionType:
+        first_args = get_args(args[0])
+        if (
+            get_origin(args[0]) is nt.ProcNode
+            and first_args
+            and first_args[0] is args[1]
+        ):
+            return f"t.SocketOrVal[{repr_type(first_args[0])}]"
+        return " | ".join([repr_type(a) for a in args])
+
+    if x.__name__ == "NoneType":
+        return "None"
+
     if x.__name__ == "ProcNode":
         if len(args) == 1:
             return f"pf.ProcNode[{repr_type(args[0])}]"
@@ -42,16 +53,6 @@ def repr_type(x: Any) -> str:
     if x.__module__ == "builtins":
         return x.__name__
 
-    origin = get_origin(x)
-    args = get_args(x)
-
-    if origin is Union:
-        args_0 = get_args(args[0])
-        if get_origin(args[0]) is nt.ProcNode and args_0[0] is args[1]:
-            return f"t.SocketOrVal[{repr_type(args_0[0])}]"
-        else:
-            return " | ".join([repr_type(a) for a in args])
-
     if getattr(x, "__module__", None) == "procfunc.nodes.types":
         return f"t.{x.__name__}"
 
@@ -70,12 +71,12 @@ def repr_value(value: Any) -> str:
         value = value.__wrapped__
 
     if isinstance(value, cg.Proxy):
-        logger.warning(
+        raise ValueError(
             f"Proxy object {value} should never appear as a raw value in codegen - "
             f"its underlying node {value.node} was not resolved to a variable"
         )
     if isinstance(value, nt.ProcNode):
-        logger.warning(
+        raise ValueError(
             f"Procnode object {value} should never be treated as a raw value in codegen"
         )
 

{procfunc-0.33.1 → procfunc-0.35.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.35.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.35.0}/src/procfunc/compute_graph/proxy.py

@@ -15,6 +15,10 @@ class Proxy(Generic[T]):
 
     node: Node
 
+    # Tell numpy to defer (ndarray + Proxy -> Proxy.__radd__) instead of probing the
+    # Proxy as an array, which would fabricate a bogus __array_struct__ via __getattr__.
+    __array_ufunc__ = None
+
     def __repr__(self):
         return f"Proxy({self.node!r})"
 

{procfunc-0.33.1 → procfunc-0.35.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.35.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.35.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.35.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.35.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.35.0}/src/procfunc/nodes/execute/execute.py

@@ -67,7 +67,7 @@ def to_environment(
     return pt.World(world)
 
 
-@tracer_primitive
+@tracer_primitive(mutates=["light"])
 def to_light(
     light: pt.LightObject,
     surface: nt.ProcNode[nt.Shader],