procfunc 0.34.0__tar.gz → 0.35.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.34.0
+Version: 0.35.1
 Summary: Function-Oriented Abstractions for Procedural 3D Generation in Python
 License-Expression: BSD-3-Clause
 Project-URL: Homepage, https://github.com/princeton-vl/procfunc
@@ -9,15 +9,18 @@ Requires-Python: <3.12,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: bpy==4.2.0
-Requires-Dist: numpy<2
-Requires-Dist: pandas
+Requires-Dist: numpy<2,>=1.23.5
+Requires-Dist: pandas>=1.5
+Provides-Extra: test
+Requires-Dist: pytest<10,>=7.2; extra == "test"
 Provides-Extra: dev
-Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest<10,>=7.2; 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"
+Requires-Dist: coverage; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"

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

@@ -11,8 +11,8 @@ license = "BSD-3-Clause"
 requires-python = ">=3.11,<3.12"
 dependencies = [
     "bpy==4.2.0",
-    "numpy<2",
-    "pandas",
+    "numpy>=1.23.5,<2",
+    "pandas>=1.5",
 ]
 
 [project.urls]
@@ -23,13 +23,17 @@ Repository = "https://github.com/princeton-vl/procfunc"
 procfunc = "procfunc.cli:cli"
 
 [project.optional-dependencies]
+test = [
+    "pytest>=7.2,<10",
+]
 dev = [
-    "pytest",
+    "pytest>=7.2,<10",
     "pytest-xdist",
     "ruff>=0.15,<0.16",
     "ty",
     "imageio",
     "matplotlib",
+    "coverage",
 ]
 docs = [
     "sphinx",

{procfunc-0.34.0 → procfunc-0.35.1}/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.1"
 
 from numpy.random import Generator as RNG
 

{procfunc-0.34.0 → procfunc-0.35.1}/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.1}/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.1}/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.1}/src/procfunc/context.py

@@ -19,6 +19,13 @@ class ProcfuncContext:
     'ignore' silently returns an empty mesh, 'warn' logs a warning, 'throw' raises an error.
     """
 
+    record_node_definitions: bool = False
+    """
+    Record the user-space file/line/function that constructed each ProcNode, used only to
+    enrich node-instantiation error messages. Walks the stack once per node, which can
+    dominate build time in node-heavy callers, so off by default.
+    """
+
     def __post_init__(self):
         """Initialize computed fields after dataclass creation."""
         if self.num_cpu_cores <= 0:
@@ -44,6 +51,8 @@ globals = ProcfuncContext(
     num_cpu_cores=int(os.environ.get("PROCFUNC_NUM_CPU_CORES", 0)),
     warn_mode_empty_geonodes=_warn_mode_empty_geonodes,  # type: ignore[invalid-assignment]
     current_trace_level=None,
+    record_node_definitions=os.environ.get("PROCFUNC_RECORD_NODE_DEFINITIONS", "0")
+    == "1",
 )
 
 

{procfunc-0.34.0 → procfunc-0.35.1}/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.1}/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.1}/src/procfunc/nodes/types.py

@@ -5,6 +5,7 @@ from pathlib import Path
 from typing import Any, Generic, TypeVar, Union
 
 from procfunc import compute_graph as cg
+from procfunc import context
 from procfunc import types as pt
 from procfunc.compute_graph.operators_info import (
     OPERATORS_TO_FUNCTIONS,
@@ -79,7 +80,8 @@ class ProcNode(Generic[T]):
                 f"these should have been unwrapped to cg.Node {node.args} {node.kwargs}"
             )
 
-        self._node.metadata["definition"] = _node_definition_metadata()
+        if context.globals.record_node_definitions:
+            self._node.metadata["definition"] = _node_definition_metadata()
 
     def astype(self, dtype: type) -> "ProcNode":
         node = copy.copy(self._node)
@@ -114,7 +116,8 @@ class ProcNode(Generic[T]):
             )
 
         node = cg.ProceduralNode(node_type=node_type, attrs=attrs, kwargs=inputs)
-        node.metadata["definition"] = _node_definition_metadata()
+        if context.globals.record_node_definitions:
+            node.metadata["definition"] = _node_definition_metadata()
 
         return cls(node=node)
 
@@ -262,7 +265,11 @@ def node_definition_context_message(node: cg.Node):
     metadata = object.__getattribute__(node, "metadata")
     lineno_metadata = metadata.get("definition", None)
     if lineno_metadata is None:
-        return ""
+        return (
+            " (set PROCFUNC_RECORD_NODE_DEFINITIONS=1 or "
+            "override_globals(record_node_definitions=True) to see the "
+            "file/line that defined this node) "
+        )
     file, lineno, procfunc_name = lineno_metadata
     return f" {procfunc_name}() call on {file}:{lineno} "
 

{procfunc-0.34.0 → procfunc-0.35.1}/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.1}/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.1}/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.1}/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,