procfunc 0.34.0__tar.gz → 0.35.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.34.0
+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

{procfunc-0.34.0 → 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.34.0"
+__version__ = "0.35.0"
 
 from numpy.random import Generator as RNG
 

{procfunc-0.34.0 → 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.34.0 → 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.34.0 → 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.34.0 → 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],

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/nodes/execute/realize.py

@@ -5,13 +5,13 @@ import bpy
 from procfunc import compute_graph as cg
 from procfunc import types as pt
 from procfunc.nodes import types as nt
-from procfunc.nodes.util.bpy_node_info import NodeGroupType, SocketType
+from procfunc.nodes.util.bpy_node_info import SocketType
 from procfunc.ops._util import modify
 from procfunc.ops.primitives.mesh import mesh_single_vertex
-from procfunc.util import pytree
 from procfunc.util.bpy_info import bpy_nocollide_data_name
 
-from .construct_nodes import as_nodegroup, instantiate_nodegroup
+from . import construct_standard
+from .construct_nodes import construct_procnode_to_bpy, instantiate_nodegroup
 
 logger = logging.getLogger(__name__)
 
@@ -81,11 +81,38 @@ def nodegroup_to_output(
     return output_node
 
 
+def construct_outputs_to_output_node(
+    node_tree: bpy.types.NodeTree,
+    outputs: dict[str, cg.Node],
+    output_node_type: str,
+) -> bpy.types.Node:
+    output_node = node_tree.nodes.new(output_node_type)
+    cache = {}
+    for key, node in outputs.items():
+        res = construct_procnode_to_bpy(node, node_tree, cache)
+        if isinstance(res, bpy.types.Node):
+            res = construct_standard._get_primary_output_socket(node, res)
+        construct_standard.connect_single_input(
+            node_tree, output_node.inputs[key.capitalize()], res
+        )
+    return output_node
+
+
 def build_bpy_material(
     surface: nt.ProcNode[nt.Shader] | None = None,
     displacement: nt.ProcNode[pt.Vector] | None = None,
     volume: nt.ProcNode[nt.Shader] | None = None,
 ) -> bpy.types.Material:
+    for key, val in {
+        "surface": surface,
+        "displacement": displacement,
+        "volume": volume,
+    }.items():
+        if val is not None and not isinstance(val, (nt.ProcNode, cg.Node)):
+            raise TypeError(
+                f"Material {key} must be a ProcNode or None, got {type(val)}: {val!r}"
+            )
+
     # optimization: a constant zero displacement has no effect, so drop it and
     # leave the output socket disconnected rather than emitting a dead subgraph
     if displacement is not None and pt.is_zero_displacement(displacement):
@@ -107,15 +134,7 @@ def build_bpy_material(
     mnt = material.node_tree
     mnt.nodes.clear()
 
-    outputs = pytree.PyTree(outputs)
-    graph = cg.ComputeGraph(
-        inputs=pytree.PyTree({}),
-        outputs=outputs,
-        name="to_material",
-        metadata={},
-    )
-    body = as_nodegroup(graph, NodeGroupType.SHADER)
-    nodegroup_to_output(mnt, body, "ShaderNodeOutputMaterial", list(outputs.names()))
+    construct_outputs_to_output_node(mnt, outputs, "ShaderNodeOutputMaterial")
 
     return material
 

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/nodes/util/node_function.py

@@ -144,6 +144,12 @@ def _subgraph_call_procnode(func: Callable, subgraph: cg.ComputeGraph, *args, **
 def node_function(func: Callable):
     @functools.wraps(func)
     def node_function_wrapper(*args, **kwargs):
+        active = pf.context.globals.current_trace_level
+        if active is not None and active >= TraceLevel.NODEGROUPS.value:
+            from procfunc.tracer.trace import capture_as_function_call
+
+            return capture_as_function_call(node_function_wrapper, args, kwargs)
+
         subgraph = _execute_procnode_func_to_computegraph(func)
         subgraph.metadata["operations"] = [
             (node_function, {"func": func}),

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/ops/primitives/__init__.py

@@ -20,6 +20,7 @@ from .mesh import (
     mesh_cone,
     mesh_cube,
     mesh_cylinder,
+    mesh_from_numpy,
     mesh_grid,
     mesh_icosphere,
     mesh_line,

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/random.py

@@ -75,6 +75,7 @@ def clip_gaussian(
     )
 
 
+@pf.tracer.primitive(allow_exec=True)
 def wrap_gaussian(
     rng: np.random.Generator,
     mean: float,
@@ -92,6 +93,7 @@ def wrap_gaussian(
     return x
 
 
+@pf.tracer.primitive(allow_exec=True)
 def exponential(
     rng: np.random.Generator,
     scale: float,
@@ -99,6 +101,7 @@ def exponential(
     return rng.exponential(scale)
 
 
+@pf.tracer.primitive(allow_exec=True)
 def log_uniform(
     rng: np.random.Generator,
     low: float,
@@ -108,6 +111,7 @@ def log_uniform(
     return np.exp(rng.uniform(np.log(low), np.log(high), size=size))
 
 
+@pf.tracer.primitive(allow_exec=True)
 def log_normal(
     rng: np.random.Generator,
     mean: float,
@@ -117,6 +121,7 @@ def log_normal(
     return np.exp(rng.normal(np.log(mean), std, size=size))
 
 
+@pf.tracer.primitive(allow_exec=True)
 def spherical_sample(
     rng: np.random.Generator,
     min_elevation: float | None = None,
@@ -137,6 +142,7 @@ def spherical_sample(
     )
 
 
+@pf.tracer.primitive(allow_exec=True)
 def mixture_of_gaussian(
     rng: np.random.Generator,
     means: np.ndarray,
@@ -161,6 +167,7 @@ def mixture_of_gaussian(
     return res
 
 
+@pf.tracer.primitive(allow_exec=True)
 def beta(
     rng: np.random.Generator,
     a: float,
@@ -169,6 +176,7 @@ def beta(
     return rng.beta(a, b)
 
 
+@pf.tracer.primitive(allow_exec=True)
 def poisson(
     rng: np.random.Generator,
     lam: float,
@@ -176,6 +184,7 @@ def poisson(
     return rng.poisson(lam)
 
 
+@pf.tracer.primitive(allow_exec=True)
 def triangular(
     rng: np.random.Generator,
     low: float,
@@ -185,6 +194,7 @@ def triangular(
     return rng.triangular(low, mode, high)
 
 
+@pf.tracer.primitive(allow_exec=True)
 def gamma(
     rng: np.random.Generator,
     shape: float,
@@ -193,6 +203,7 @@ def gamma(
     return rng.gamma(shape, scale)
 
 
+@pf.tracer.primitive(allow_exec=True)
 def binomial(
     rng: np.random.Generator,
     n: int,
@@ -201,6 +212,7 @@ def binomial(
     return rng.binomial(n, p)
 
 
+@pf.tracer.primitive(allow_exec=True)
 def geometric(
     rng: np.random.Generator,
     p: float,

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/tracer/trace.py

@@ -139,6 +139,22 @@ def _map_args(
     return res
 
 
+def capture_as_function_call(func: Callable, args: tuple, kwargs: dict) -> cg.Proxy:
+    """Record a call as a single FunctionCallNode leaf without executing func's body.
+
+    The Proxy's attribute/item access becomes graph getattrs, so multi-output results
+    (e.g. a NamedTuple) work through it. Codegen re-emits this as an imported call.
+    """
+
+    def _unwrap(v):
+        return v.node if isinstance(v, cg.Proxy) else v
+
+    node_args = tuple(pytree.PyTree(a).map(_unwrap).obj() for a in args)
+    node_kwargs = {k: pytree.PyTree(v).map(_unwrap).obj() for k, v in kwargs.items()}
+    node = cg.FunctionCallNode(func=func, args=node_args, kwargs=node_kwargs)
+    return cg.Proxy(node)
+
+
 def trace(
     func: Callable,
     trace_level: TraceLevel = TraceLevel.GENERATORS,

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/transpiler/bpy_to_computegraph.py

@@ -163,6 +163,36 @@ def _remove_banned_attrs(
             )
 
 
+def _returns_named_tuple(func: Any) -> bool:
+    try:
+        return_type = get_type_hints(func).get("return")
+    except Exception:
+        return False
+    if return_type is None:
+        return False
+    origin = get_origin(return_type) or return_type
+    return (
+        isinstance(origin, type)
+        and issubclass(origin, tuple)
+        and hasattr(origin, "_fields")
+    )
+
+
+def _produces_named_outputs(node: cg.Node, link: bpy.types.NodeLink) -> bool:
+    """Whether the parsed node yields multiple named outputs, so the downstream
+    link must select a specific one via getattr. A node's procfunc function may
+    return a namedtuple of all outputs (e.g. attribute_domain_size) even when
+    the source node's mode/component disables all but one output socket, so the
+    active-socket count alone underdetects this - prefer the function's return
+    type and fall back to the socket count when it is unknown."""
+    if isinstance(node, cg.FunctionCallNode):
+        return _returns_named_tuple(node.func)
+    if isinstance(node, cg.SubgraphCallNode):
+        out = node.subgraph.outputs.obj()
+        return isinstance(out, tuple) and hasattr(out, "_fields")
+    return len(get_active_sockets(link.from_node.outputs)) > 1
+
+
 def _parse_getattr(
     res: cg.Node,
     link: bpy.types.NodeLink,
@@ -232,9 +262,8 @@ def _create_link_impl_node(
         res = parse_node(node_tree, link.from_node, memo)
         assert res is not None, link
 
-        outsockets = get_active_sockets(link.from_node.outputs)
-        assert len(outsockets) > 0
-        if len(outsockets) > 1:
+        assert len(get_active_sockets(link.from_node.outputs)) > 0
+        if _produces_named_outputs(res, link):
             res = _parse_getattr(res, link)
             assert res is not None, link
 
@@ -912,8 +941,10 @@ def _placeholder_for_graph_input(
             varname=varname,
         ),
     )
-    if default_value is not None:
-        node.kwargs["default_value"] = default_value
+    # Record the default unconditionally, even when it is None: a socket with no
+    # synthesizable value (geometry/object/collection) should still become an
+    # optional param (= None), matching v1 where every input had a default.
+    node.kwargs["default_value"] = default_value
 
     return node
 
@@ -1261,6 +1292,12 @@ def parse_material(
         if output_node.inputs[key].is_linked:
             res = parse_link(node_tree, output_node.inputs[key].links[0], memo)
             res.metadata["known_value_type"] = pf.ProcNode[expect_type]
+        elif key == "Displacement":
+            # unconnected displacement is a zero ProcNode, composable arithmetically
+            res = cg.FunctionCallNode(
+                func=pf.nodes.math.constant, args=((0.0, 0.0, 0.0),), kwargs={}
+            )
+            res.metadata["known_value_type"] = pf.ProcNode[pf.Vector]
         else:
             res = cg.ConstantNode(value=None)
             res.metadata["known_value_type"] = Union[pf.ProcNode[expect_type], None]

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/transpiler/main.py

@@ -215,7 +215,8 @@ def transpile_targets(
     result_calls = []
     for result_graph in result_graphs:
         kwargs = {}
-        if result_graph.name.startswith("material_"):
+        input_names = {name for name, _ in result_graph.inputs.items()}
+        if "vector" in input_names:
             kwargs["vector"] = vec
 
         return_type = result_graph.metadata.get("known_value_type", None)
@@ -238,6 +239,9 @@ def transpile_targets(
 
     func_resolution, import_lines = default_func_resolution_map(graph)
     for oprow in NODE_OPERATOR_TABLE:
+        # Python % is floored but Blender MODULO is truncated - keep the named call
+        if oprow.operator_type == cg.OperatorType.MOD:
+            continue
         func_resolution[oprow.pf_func] = oprow.operator_type
 
     python = to_python(

{procfunc-0.34.0 → procfunc-0.35.0}/src/procfunc/types.py

@@ -205,16 +205,29 @@ def is_zero_displacement(value: Any) -> bool:
     Such a displacement has no effect, so the material build can leave the
     output socket disconnected and skip emitting the subgraph entirely.
     """
-    from procfunc import compute_graph as cg
-    from procfunc.nodes import types as nt
+    from procfunc import compute_graph as cg  # keep-local
+    from procfunc.nodes import math as node_math  # keep-local
+    from procfunc.nodes import types as nt  # keep-local
+    from procfunc.nodes.util.bindings_util import ContextualNode  # keep-local
 
     if isinstance(value, nt.ProcNode):
         value = value.item()
-    if not isinstance(value, cg.ConstantNode):
+    if isinstance(value, cg.ConstantNode):
+        value = value.value
+    elif isinstance(value, cg.FunctionCallNode) and value.func is node_math.constant:
+        value = value.args[0]
+    elif (
+        isinstance(value, cg.ProceduralNode)
+        and value.node_type == ContextualNode.VECTOR.value
+    ):
+        value = value.attrs.get("value")
+    else:
         return False
-    return isinstance(value.value, (mathutils.Vector, tuple, list)) and tuple(
-        value.value
-    ) == (0.0, 0.0, 0.0)
+    return isinstance(value, (mathutils.Vector, tuple, list)) and tuple(value) == (
+        0.0,
+        0.0,
+        0.0,
+    )
 
 
 @dataclass
@@ -226,7 +239,9 @@ class Material:
 
     def item(self) -> bpy.types.Material:
         if self._bpy_material is None:
-            from procfunc.nodes.execute.realize import build_bpy_material
+            from procfunc.nodes.execute.realize import (  # keep-local
+                build_bpy_material,
+            )
 
             self._bpy_material = build_bpy_material(
                 surface=self.surface,

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.34.0
+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

procfunc-0.35.0/tests/test_codegen.py

@@ -0,0 +1,89 @@
+import bpy
+import numpy as np
+
+import procfunc as pf
+from procfunc.codegen import codegen
+from procfunc.codegen.identifiers import dedup_names_with_suffix
+
+
+def _codegen_and_call(func, **inputs):
+    graph = pf.trace(func)
+    src = codegen.to_python(graph, toplevel_as_maincall=False)
+    namespace = {}
+    exec(src, namespace)  # noqa: S102
+    return src, namespace[func.__name__](**inputs)
+
+
+def test_folded_operand_ending_in_call_keeps_parens():
+    def sub_of_add_astype(a, b, c):
+        return c - (a + b.astype(float))
+
+    src, result = _codegen_and_call(
+        sub_of_add_astype, a=np.float64(1.0), b=np.float64(2.0), c=np.float64(10.0)
+    )
+    assert "c - (a + b.astype(float))" in src, src
+    assert result == 7.0
+
+
+def test_negative_constant_pow_base_keeps_parens():
+    def pow_negative_base(x):
+        return (-2.0) ** x
+
+    src, result = _codegen_and_call(pow_negative_base, x=2.0)
+    assert "(-2.0) ** x" in src, src
+    assert result == 4.0
+
+
+def _lamp_with_blackbody_emission():
+    light = pf.ops.primitives.light.point_lamp(100.0)
+    color = pf.nodes.color.blackbody(3000.0)
+    emit = pf.nodes.shader.emission(color=color, strength=5.0)
+    pf.nodes.execute.execute.to_light(light, surface=emit)
+    return light
+
+
+def _tree_has_node(tree, bl_idname):
+    for n in tree.nodes:
+        if n.bl_idname == bl_idname:
+            return True
+        if n.bl_idname == "ShaderNodeGroup" and n.node_tree is not None:
+            if _tree_has_node(n.node_tree, bl_idname):
+                return True
+    return False
+
+
+def test_to_light_shader_survives_codegen():
+    graph = pf.trace(_lamp_with_blackbody_emission)
+    code = codegen.to_python(graph, toplevel_as_maincall=False)
+    assert "to_light" in code, code
+
+    bpy.ops.wm.read_factory_settings(use_empty=True)
+    namespace = {}
+    exec(code, namespace)  # noqa: S102
+    namespace["_lamp_with_blackbody_emission"]()
+
+    lit = [
+        light
+        for light in bpy.data.lights
+        if light.use_nodes
+        and light.node_tree is not None
+        and _tree_has_node(light.node_tree, "ShaderNodeBlackbody")
+    ]
+    assert lit, "re-executed light lost its Blackbody emission shader"
+
+
+def test_dedup_suffix_collides_with_later_base_name():
+    names = {
+        0: "a_1",  # strips to 'a'
+        1: "a_2",  # strips to 'a'
+        2: "a_0_3",  # strips to 'a_0'
+    }
+    result = dedup_names_with_suffix(
+        names,
+        separator="_",
+        order=[0, 1, 2],
+        first_use_suffix=True,
+    )
+    print(f"{result=}")
+    values = list(result.values())
+    assert len(values) == len(set(values)), f"Duplicate names in {values}"

procfunc-0.35.0/tests/test_random.py

@@ -0,0 +1,73 @@
+import numpy as np
+import pytest
+
+import procfunc as pf
+from procfunc import compute_graph as cg
+
+_distribution_calls = {
+    pf.random.uniform: lambda rng: pf.random.uniform(rng, 0.1, 1.0),
+    pf.random.normal: lambda rng: pf.random.normal(rng, 0.0, 1.0),
+    pf.random.randint: lambda rng: pf.random.randint(rng, 0, 10),
+    pf.random.uniform_tails: lambda rng: pf.random.uniform_tails(rng, 0.0, 1.0),
+    pf.random.clip_gaussian: lambda rng: pf.random.clip_gaussian(rng, 0.0, 1.0),
+    pf.random.wrap_gaussian: lambda rng: pf.random.wrap_gaussian(
+        rng, 0.0, 1.0, -1.0, 1.0
+    ),
+    pf.random.exponential: lambda rng: pf.random.exponential(rng, 1.0),
+    pf.random.log_uniform: lambda rng: pf.random.log_uniform(rng, 0.4, 2.0),
+    pf.random.log_normal: lambda rng: pf.random.log_normal(rng, 1.0, 0.5),
+    pf.random.spherical_sample: lambda rng: pf.random.spherical_sample(rng),
+    pf.random.mixture_of_gaussian: lambda rng: pf.random.mixture_of_gaussian(
+        rng, np.array([0.0, 5.0]), np.array([1.0, 1.0]), [1.0, 1.0]
+    ),
+    pf.random.beta: lambda rng: pf.random.beta(rng, 2.0, 5.0),
+    pf.random.poisson: lambda rng: pf.random.poisson(rng, 3.0),
+    pf.random.triangular: lambda rng: pf.random.triangular(rng, 0.0, 1.0, 0.5),
+    pf.random.gamma: lambda rng: pf.random.gamma(rng, 2.0, 1.0),
+    pf.random.binomial: lambda rng: pf.random.binomial(rng, 10, 0.5),
+    pf.random.geometric: lambda rng: pf.random.geometric(rng, 0.3),
+}
+
+
+def test_distribution_call_table_is_complete():
+    assert set(_distribution_calls) >= set(pf.random.random_distrib_funcs)
+
+
+@pytest.mark.parametrize("func", list(_distribution_calls), ids=lambda f: f.__name__)
+def test_distribution_bakes_to_constant_when_traced(func):
+    def generator(rng):
+        return _distribution_calls[func](rng)
+
+    graph = pf.trace(
+        generator,
+        rng=np.random.default_rng(0),
+        trace_level=pf.tracer.TraceLevel.GENERATORS,
+    )
+    out = list(graph.outputs.dict().values())[0]
+    assert isinstance(out, cg.ConstantNode)
+
+
+def test_clip_gaussian_respects_zero_bounds():
+    """low=0.0 / high=0.0 are real bounds, not "unset"."""
+    rng = np.random.default_rng(0)
+    samples = [
+        pf.random.clip_gaussian(
+            rng, mean=-0.5, std=1.0, low=0.0, high=2.0, max_tries=1000
+        )
+        for _ in range(50)
+    ]
+    assert all(0.0 <= s <= 2.0 for s in samples)
+
+    samples = [
+        pf.random.clip_gaussian(
+            rng, mean=0.5, std=1.0, low=-2.0, high=0.0, max_tries=1000
+        )
+        for _ in range(50)
+    ]
+    assert all(-2.0 <= s <= 0.0 for s in samples)
+
+
+def test_clip_gaussian_default_bounds():
+    rng = np.random.default_rng(0)
+    samples = [pf.random.clip_gaussian(rng, mean=5.0, std=1.0) for _ in range(50)]
+    assert all(2.0 <= s <= 8.0 for s in samples)

procfunc-0.34.0/tests/test_codegen.py

@@ -1,18 +0,0 @@
-from procfunc.codegen.identifiers import dedup_names_with_suffix
-
-
-def test_dedup_suffix_collides_with_later_base_name():
-    names = {
-        0: "a_1",  # strips to 'a'
-        1: "a_2",  # strips to 'a'
-        2: "a_0_3",  # strips to 'a_0'
-    }
-    result = dedup_names_with_suffix(
-        names,
-        separator="_",
-        order=[0, 1, 2],
-        first_use_suffix=True,
-    )
-    print(f"{result=}")
-    values = list(result.values())
-    assert len(values) == len(set(values)), f"Duplicate names in {values}"

procfunc-0.34.0/tests/test_random.py

@@ -1,29 +0,0 @@
-import numpy as np
-
-import procfunc as pf
-
-
-def test_clip_gaussian_respects_zero_bounds():
-    """low=0.0 / high=0.0 are real bounds, not "unset"."""
-    rng = np.random.default_rng(0)
-    samples = [
-        pf.random.clip_gaussian(
-            rng, mean=-0.5, std=1.0, low=0.0, high=2.0, max_tries=1000
-        )
-        for _ in range(50)
-    ]
-    assert all(0.0 <= s <= 2.0 for s in samples)
-
-    samples = [
-        pf.random.clip_gaussian(
-            rng, mean=0.5, std=1.0, low=-2.0, high=0.0, max_tries=1000
-        )
-        for _ in range(50)
-    ]
-    assert all(-2.0 <= s <= 0.0 for s in samples)
-
-
-def test_clip_gaussian_default_bounds():
-    rng = np.random.default_rng(0)
-    samples = [pf.random.clip_gaussian(rng, mean=5.0, std=1.0) for _ in range(50)]
-    assert all(2.0 <= s <= 8.0 for s in samples)