procfunc 0.36.0__tar.gz → 0.36.1__tar.gz

{procfunc-0.36.0/src/procfunc.egg-info → procfunc-0.36.1}/PKG-INFO

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

{procfunc-0.36.0 → procfunc-0.36.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.36.0"
+__version__ = "0.36.1"
 
 from numpy.random import Generator as RNG
 

{procfunc-0.36.0 → procfunc-0.36.1}/src/procfunc/codegen/codegen.py

@@ -606,7 +606,8 @@ def _codegen_for_assignment(
 def _expressions_scope_for_graph(
     graph: cg.ComputeGraph,
     scope_expressions: dict[int, str | list[str]],
-) -> tuple[dict[int, str | list[str]], dict[int, bool]]:
+    fold_map: dict[int, bool],
+) -> dict[int, str | list[str]]:
     expressions: dict[int, str | list[str]] = {
         **scope_expressions.copy(),
         **_check_graph_input_names(graph, scope_expressions),
@@ -615,9 +616,6 @@ def _expressions_scope_for_graph(
     # when we want to refer to a value, what string should we insert?
     # - for most nodes: refer to a variable name
     # - for inlined expressions: emplace a expression string
-    usages = cg.usages_per_node(graph)
-    fold_map = _expression_fold_map(graph, expressions, usages=usages)
-
     node_names = identifiers.nodenames_from_fixed_and_infill(
         graph,
         fold_map=fold_map,
@@ -630,7 +628,7 @@ def _expressions_scope_for_graph(
         raise ValueError(f"Scope and node names had overlap: {intersection=}")
     expressions.update(node_names)
 
-    return expressions, fold_map
+    return expressions
 
 
 def _codegen_for_graph(
@@ -646,17 +644,13 @@ def _codegen_for_graph(
     if add_version_comment:
         code_lines.append(f"# Code generated by procfunc v{pf.__version__}")
 
-    expressions, fold_map = _expressions_scope_for_graph(graph, scope_expressions)
+    usages = cg.usages_per_node(graph)
+    fold_map = _expression_fold_map(graph, scope_expressions, usages)
+    expressions = _expressions_scope_for_graph(graph, scope_expressions, fold_map)
     _input_ids = set(id(node) for node in graph.inputs.values())  # noqa: F841
-
+    output_ids = {id(node) for node in graph.outputs.values()}
     last_varname: str = ""
 
-    # Collect mutator call nodes so they emit as bare statements (no assignment)
-    mutator_call_ids = set()
-    for node in cg.traverse_depth_first(graph):
-        if isinstance(node, cg.MutatedArgumentNode):
-            mutator_call_ids.add(id(node.args[1]))
-
     for node in cg.traverse_depth_first(graph):
         if isinstance(node, cg.InputPlaceholderNode):
             continue  # arguments are defined in _codegen_graph_inputs
@@ -673,7 +667,17 @@ def _codegen_for_graph(
             expressions[id(node)] = node_code
             continue
 
-        if id(node) in mutator_call_ids:
+        node_usages = usages.get(id(node), [])
+        mutation_usages = [
+            usage
+            for usage in node_usages
+            if isinstance(usage, cg.MutatedArgumentNode) and usage.args[1] is node
+        ]
+        if (
+            mutation_usages
+            and mutation_usages == node_usages
+            and id(node) not in output_ids
+        ):
             code_lines.extend(node_code if isinstance(node_code, list) else [node_code])
             continue
 

{procfunc-0.36.0 → procfunc-0.36.1}/src/procfunc/random.py

@@ -10,7 +10,7 @@ T = TypeVar("T")
 logger = logging.getLogger(__name__)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def uniform(
     rng: np.random.Generator,
     low: float,
@@ -19,7 +19,7 @@ def uniform(
     return rng.uniform(low, high)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def normal(
     rng: np.random.Generator,
     mean: float,
@@ -28,7 +28,7 @@ def normal(
     return rng.normal(mean, std)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def randint(
     rng: np.random.Generator,
     low: int,
@@ -37,7 +37,7 @@ def randint(
     return rng.integers(low, high)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def uniform_tails(
     rng: np.random.Generator,
     low: float,
@@ -50,7 +50,7 @@ def uniform_tails(
         return rng.uniform(high - (high - low) * tail_pct, high)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def clip_gaussian(
     rng: np.random.Generator,
     mean: float,
@@ -75,7 +75,7 @@ def clip_gaussian(
     )
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def wrap_gaussian(
     rng: np.random.Generator,
     mean: float,
@@ -93,7 +93,7 @@ def wrap_gaussian(
     return x
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def exponential(
     rng: np.random.Generator,
     scale: float,
@@ -101,7 +101,7 @@ def exponential(
     return rng.exponential(scale)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def log_uniform(
     rng: np.random.Generator,
     low: float,
@@ -111,7 +111,7 @@ def log_uniform(
     return np.exp(rng.uniform(np.log(low), np.log(high), size=size))
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def log_normal(
     rng: np.random.Generator,
     mean: float,
@@ -121,7 +121,7 @@ def log_normal(
     return np.exp(rng.normal(np.log(mean), std, size=size))
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def spherical_sample(
     rng: np.random.Generator,
     min_elevation: float | None = None,
@@ -142,7 +142,7 @@ def spherical_sample(
     )
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def mixture_of_gaussian(
     rng: np.random.Generator,
     means: np.ndarray,
@@ -167,7 +167,7 @@ def mixture_of_gaussian(
     return res
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def beta(
     rng: np.random.Generator,
     a: float,
@@ -176,7 +176,7 @@ def beta(
     return rng.beta(a, b)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def poisson(
     rng: np.random.Generator,
     lam: float,
@@ -184,7 +184,7 @@ def poisson(
     return rng.poisson(lam)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def triangular(
     rng: np.random.Generator,
     low: float,
@@ -194,7 +194,7 @@ def triangular(
     return rng.triangular(low, mode, high)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def gamma(
     rng: np.random.Generator,
     shape: float,
@@ -203,7 +203,7 @@ def gamma(
     return rng.gamma(shape, scale)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def binomial(
     rng: np.random.Generator,
     n: int,
@@ -212,7 +212,7 @@ def binomial(
     return rng.binomial(n, p)
 
 
-@pf.tracer.primitive(allow_exec=True)
+@pf.tracer.primitive(allow_exec=True, mutates=["rng"])
 def geometric(
     rng: np.random.Generator,
     p: float,

{procfunc-0.36.0 → procfunc-0.36.1}/src/procfunc/tracer/trace.py

@@ -181,6 +181,11 @@ def trace(
         name = func.__name__
 
     proxy_args = _map_args(func, **inputs)
+    input_nodes = {
+        k: v.node
+        for k, v in proxy_args.items()
+        if isinstance(v, cg.Proxy) and isinstance(v.node, cg.InputPlaceholderNode)
+    }
 
     if pf.context.globals.current_trace_level is not None:
         # TODO we can lift this restriction fairly(?) easily by having a global patcher & saving/restoring this state
@@ -222,12 +227,6 @@ def trace(
     outputs = pytree.PyTree(func_result)
     outputs = outputs.map(extract_node)
 
-    input_nodes = {
-        k: v.node
-        for k, v in proxy_args.items()
-        if isinstance(v, cg.Proxy) and isinstance(v.node, cg.InputPlaceholderNode)
-    }
-
     compgraph = cg.ComputeGraph(
         inputs=pytree.PyTree(input_nodes),
         outputs=outputs,

{procfunc-0.36.0 → procfunc-0.36.1/src/procfunc.egg-info}/PKG-INFO

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

{procfunc-0.36.0 → procfunc-0.36.1}/src/procfunc.egg-info/SOURCES.txt

@@ -103,6 +103,7 @@ tests/test_node_function.py
 tests/test_ops.py
 tests/test_pytree.py
 tests/test_random.py
+tests/test_random_mutation.py
 tests/test_teardown.py
 tests/test_trace.py
 tests/test_transforms.py

procfunc-0.36.1/tests/test_random_mutation.py

@@ -0,0 +1,92 @@
+import ast
+from collections.abc import Callable
+
+import numpy as np
+import pytest
+
+import procfunc as pf
+from procfunc.codegen import codegen
+
+RANDOM_CALLS = [
+    ("uniform", (0.0, 1.0)),
+    ("normal", (0.0, 1.0)),
+    ("randint", (0, 10)),
+    ("uniform_tails", (0.0, 1.0)),
+    ("clip_gaussian", (0.0, 1.0)),
+    ("wrap_gaussian", (0.0, 1.0, -1.0, 1.0)),
+    ("exponential", (1.0,)),
+    ("log_uniform", (0.4, 2.0)),
+    ("log_normal", (1.0, 0.5)),
+    ("spherical_sample", ()),
+    ("mixture_of_gaussian", ([0.0, 5.0], [1.0, 1.0], [1.0, 1.0])),
+    ("beta", (2.0, 5.0)),
+    ("poisson", (3.0,)),
+    ("triangular", (0.0, 1.0, 0.5)),
+    ("gamma", (2.0, 1.0)),
+    ("binomial", (10, 0.5)),
+    ("geometric", (0.3,)),
+]
+TRACE_LEVELS = [
+    pf.tracer.TraceLevel.RANDOM_PARAMS,
+    pf.tracer.TraceLevel.RANDOM_CONTROL,
+    pf.tracer.TraceLevel.PRIMITIVES,
+]
+
+
+def generated_function(
+    generator: Callable, level: pf.tracer.TraceLevel, concrete: bool
+) -> Callable:
+    inputs = {"rng": np.random.default_rng(17)} if concrete else {}
+    graph = pf.trace(generator, trace_level=level, **inputs)
+    source = codegen.to_python(graph, toplevel_as_maincall=False)
+    source = source.replace("np.random.default_rng()", "np.random.default_rng(17)")
+    namespace = {}
+    exec(source, namespace)  # noqa: S102
+    return namespace[generator.__name__]
+
+
+def test_unused_mutator_return_emits_bare_call() -> None:
+    def generator(rng):
+        pf.random.uniform(rng, 0.0, 1.0)
+        return pf.random.uniform(rng, 0.0, 1.0)
+
+    graph = pf.trace(generator, trace_level=pf.tracer.TraceLevel.RANDOM_PARAMS)
+    tree = ast.parse(codegen.to_python(graph, toplevel_as_maincall=False))
+    function = next(node for node in tree.body if isinstance(node, ast.FunctionDef))
+    assert isinstance(function.body[0], ast.Expr)
+    assert isinstance(function.body[1], ast.Assign)
+
+
+@pytest.mark.parametrize("name,args", RANDOM_CALLS, ids=[x[0] for x in RANDOM_CALLS])
+@pytest.mark.parametrize("level", TRACE_LEVELS, ids=lambda level: level.name)
+@pytest.mark.parametrize("concrete", [False, True], ids=["input", "seeded"])
+def test_discarded_random_draw_advances_generated_rng(
+    name: str, args: tuple, level: pf.tracer.TraceLevel, concrete: bool
+) -> None:
+    def generator(rng):
+        getattr(pf.random, name)(rng, *args)
+        return pf.random.uniform(rng, 0.0, 1.0)
+
+    generated = generated_function(generator, level, concrete)
+    expected = generator(np.random.default_rng(17))
+    actual = generated() if concrete else generated(np.random.default_rng(17))
+    tolerance = 1e-7 if concrete and level < pf.tracer.TraceLevel.RANDOM_PARAMS else 0
+    assert actual == pytest.approx(expected, rel=tolerance, abs=0)
+
+
+@pytest.mark.parametrize("level", TRACE_LEVELS, ids=lambda level: level.name)
+@pytest.mark.parametrize("concrete", [False, True], ids=["input", "seeded"])
+def test_reversed_outputs_preserve_aliased_rng_order(
+    level: pf.tracer.TraceLevel, concrete: bool
+) -> None:
+    def generator(rng):
+        other = rng
+        width = pf.random.uniform(rng, 1.0, 2.0)
+        height = pf.random.uniform(other, 3.0, 4.0)
+        return {"height": height, "width": width}
+
+    generated = generated_function(generator, level, concrete)
+    expected = generator(np.random.default_rng(17))
+    actual = generated() if concrete else generated(np.random.default_rng(17))
+    tolerance = 1e-7 if concrete and level < pf.tracer.TraceLevel.RANDOM_PARAMS else 0
+    assert actual == pytest.approx(expected, rel=tolerance, abs=0)