procfunc 0.30.0__tar.gz

procfunc-0.30.0/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2026 Princeton University
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

procfunc-0.30.0/PKG-INFO

@@ -0,0 +1,120 @@
+Metadata-Version: 2.4
+Name: procfunc
+Version: 0.30.0
+Summary: A framework for compositional procedural generation
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://github.com/princeton-vl/procfunc
+Project-URL: Repository, https://github.com/princeton-vl/procfunc
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: bpy==4.2.0
+Requires-Dist: numpy<2
+Requires-Dist: pandas
+Provides-Extra: dev
+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"
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Dynamic: license-file
+
+# ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python
+
+[**Documentation**](#documentation)
+| [**Research Paper**](#paper)
+| [**Documentation**](#paper)
+| [**Transpiling**](#transpile-a-blender-file-to-procfunc-code)
+| [**Experiments**](#experiments)
+| [**Contributing**](#contributing)
+
+This repository contains only the Primitives API, Transpiler and Tracer from our research paper.
+
+The pre-made procedural generators are coming soon as part of [infinigen](https://github.com/princeton-vl/infinigen).
+
+### Installation
+
+Use [uv](https://docs.astral.sh/uv/getting-started/installation/) or your favorite package manager to install procfunc via pip:
+```bash
+uv pip install procfunc
+```
+
+Note: ProcFunc depends on `bpy==4.2.0` which then requires Python==3.11.x. Other version are not yet supported.
+
+Since we have not yet reached [semver 1.0.0](https://semver.org/) we have not yet finalized procfunc's interface. 
+In the meantime, each 0.X.0 may introduce interface changes. Please pin `uv add procfunc<0.XX` where X is the current version.
+
+### Usage
+
+See [procfunc.readthedocs.io](https://procfunc.readthedocs.io) for available functions
+
+Please create Github Issues for any bugs or  unclear interfaces!
+
+##### Transpile a blender file to ProcFunc code
+
+<p float="left">
+  <img src="examples/transpile_simple_chair/blender_screenshot.png" height="200" />
+  <img src="examples/transpile_simple_chair/code_screenshot.png" height="200" />
+</p>
+
+Convert a Blender geometry node tree into procfunc Python code by downloading our example blend and executing the transpiler:
+```bash
+wget https://raw.githubusercontent.com/princeton-vl/procfunc/main/examples/transpile_simple_chair/simple_chair.blend
+uv run python -m procfunc.transpiler.main simple_chair.blend --node_trees simple_chair --output transpiled_code.py
+```
+
+See the expected output in [`examples/transpile_simple_chair/transpiled_code.py`](examples/transpile_simple_chair/transpiled_code.py).
+To use the code, you can add `pf.ops.file.save_blend("test.blend")` to the end of it, then open the generated blender file.
+You can also open and edit the blender geonodes prior to transpiling in order to generate different procfunc code.
+
+### Paper
+
+If you find procfunc useful, please cite our paper:
+```
+@misc{raistrick2026procfunc,
+      title={ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python}, 
+      author={Alexander Raistrick and Karhan Kayan and Jack Nugent and David Yan and Lingjie Mei and Meenal Parakh and Hongyu Wen and Dylan Li and Yiming Zuo and Erich Liang and Jia Deng},
+      year={2026},
+      eprint={2604.26943},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2604.26943}, 
+}
+```
+
+### Experiments
+
+See [experiments/EXPERIMENTS.md](experiments/EXPERIMENTS.md)
+
+NOTE: experiments are only intended to be correct when using the `experiments` branch, which will not see major updates.
+
+### Contributing
+
+Please create an issue for any proposed features to discuss them before implementing.
+
+##### Developer Installation
+```bash
+git clone git@github.com:princeton-vl/procfunc.git
+cd procfunc
+uv venv
+uv pip install -e ".[dev]"
+```
+
+##### Tools
+
+```bash
+uv run ruff format
+uv run ruff check --fix
+uv run pytest
+make docs
+```
+
+##### Todos / Sharp Edges
+
+Add optional support for bpy==4.x and 5.x and maybe 3.6, all under the same procfunc interface. 
+
+pf.ops is missing some blender functions and arguments, especially returning "selection" masks for some cases. 
+
+Assets like pf.MeshObject and pf.Material are not currently cleaned up upon going out of scope 

procfunc-0.30.0/README.md

@@ -0,0 +1,97 @@
+# ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python
+
+[**Documentation**](#documentation)
+| [**Research Paper**](#paper)
+| [**Documentation**](#paper)
+| [**Transpiling**](#transpile-a-blender-file-to-procfunc-code)
+| [**Experiments**](#experiments)
+| [**Contributing**](#contributing)
+
+This repository contains only the Primitives API, Transpiler and Tracer from our research paper.
+
+The pre-made procedural generators are coming soon as part of [infinigen](https://github.com/princeton-vl/infinigen).
+
+### Installation
+
+Use [uv](https://docs.astral.sh/uv/getting-started/installation/) or your favorite package manager to install procfunc via pip:
+```bash
+uv pip install procfunc
+```
+
+Note: ProcFunc depends on `bpy==4.2.0` which then requires Python==3.11.x. Other version are not yet supported.
+
+Since we have not yet reached [semver 1.0.0](https://semver.org/) we have not yet finalized procfunc's interface. 
+In the meantime, each 0.X.0 may introduce interface changes. Please pin `uv add procfunc<0.XX` where X is the current version.
+
+### Usage
+
+See [procfunc.readthedocs.io](https://procfunc.readthedocs.io) for available functions
+
+Please create Github Issues for any bugs or  unclear interfaces!
+
+##### Transpile a blender file to ProcFunc code
+
+<p float="left">
+  <img src="examples/transpile_simple_chair/blender_screenshot.png" height="200" />
+  <img src="examples/transpile_simple_chair/code_screenshot.png" height="200" />
+</p>
+
+Convert a Blender geometry node tree into procfunc Python code by downloading our example blend and executing the transpiler:
+```bash
+wget https://raw.githubusercontent.com/princeton-vl/procfunc/main/examples/transpile_simple_chair/simple_chair.blend
+uv run python -m procfunc.transpiler.main simple_chair.blend --node_trees simple_chair --output transpiled_code.py
+```
+
+See the expected output in [`examples/transpile_simple_chair/transpiled_code.py`](examples/transpile_simple_chair/transpiled_code.py).
+To use the code, you can add `pf.ops.file.save_blend("test.blend")` to the end of it, then open the generated blender file.
+You can also open and edit the blender geonodes prior to transpiling in order to generate different procfunc code.
+
+### Paper
+
+If you find procfunc useful, please cite our paper:
+```
+@misc{raistrick2026procfunc,
+      title={ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python}, 
+      author={Alexander Raistrick and Karhan Kayan and Jack Nugent and David Yan and Lingjie Mei and Meenal Parakh and Hongyu Wen and Dylan Li and Yiming Zuo and Erich Liang and Jia Deng},
+      year={2026},
+      eprint={2604.26943},
+      archivePrefix={arXiv},
+      primaryClass={cs.CV},
+      url={https://arxiv.org/abs/2604.26943}, 
+}
+```
+
+### Experiments
+
+See [experiments/EXPERIMENTS.md](experiments/EXPERIMENTS.md)
+
+NOTE: experiments are only intended to be correct when using the `experiments` branch, which will not see major updates.
+
+### Contributing
+
+Please create an issue for any proposed features to discuss them before implementing.
+
+##### Developer Installation
+```bash
+git clone git@github.com:princeton-vl/procfunc.git
+cd procfunc
+uv venv
+uv pip install -e ".[dev]"
+```
+
+##### Tools
+
+```bash
+uv run ruff format
+uv run ruff check --fix
+uv run pytest
+make docs
+```
+
+##### Todos / Sharp Edges
+
+Add optional support for bpy==4.x and 5.x and maybe 3.6, all under the same procfunc interface. 
+
+pf.ops is missing some blender functions and arguments, especially returning "selection" masks for some cases. 
+
+Assets like pf.MeshObject and pf.Material are not currently cleaned up upon going out of scope 

procfunc-0.30.0/pyproject.toml

@@ -0,0 +1,67 @@
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "procfunc"
+version = "0.30.0"
+description = "A framework for compositional procedural generation"
+readme = "README.md"
+license = "BSD-3-Clause"
+requires-python = ">=3.11"
+dependencies = [
+    "bpy==4.2.0",
+    "numpy<2",
+    "pandas",
+]
+
+[project.urls]
+Homepage = "https://github.com/princeton-vl/procfunc"
+Repository = "https://github.com/princeton-vl/procfunc"
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "pytest-xdist",
+    "ruff>=0.15,<0.16",
+    "ty"
+]
+docs = [
+    "sphinx",
+    "sphinx-rtd-theme",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+procfunc = ["**/*.json"]
+
+[tool.pytest.ini_options]
+testpaths = "tests"
+
+[tool.ruff]
+exclude = ["examples", "experiments"]
+
+[tool.ruff.lint]
+
+select = [
+    "E",
+    "I",
+    "F",
+    "S102", # no exec(),
+    "TID251", # custom banned imports
+    "TID252", # relative imports only allowed for siblings
+
+]
+ignore = [
+    "E501", # over-length lines, formatter should handle it
+    "E741", # ambigous variable name
+]
+
+[tool.ruff.lint.per-file-ignores]
+"__init__.py" = ["F401"]
+
+[tool.ty.rules]
+unresolved-import = "ignore"
+unresolved-attribute = "ignore"

procfunc-0.30.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

procfunc-0.30.0/src/procfunc/__init__.py

@@ -0,0 +1,87 @@
+# ruff: noqa: I001, F401
+# ensure this gets imported first so that mathutils etc is available even if later modules dont import bpy
+import bpy
+
+__version__ = "0.30.0"
+
+from numpy.random import Generator as RNG
+
+# ensure these are always imported first and in the right order
+import bpy as _bpy
+import mathutils as _mu
+
+from . import (
+    compute_graph,
+    control,
+    nodes,
+    ops,
+    random,
+    tracer,
+    util,
+    context,
+    color,
+    transforms,
+)
+from .types import (
+    Vector,
+    Color,
+    Euler,
+    Quaternion,
+    Matrix,
+    BVHTree,
+    Object,
+    CameraObject,
+    MeshObject,
+    CurveObject,
+    VolumeObject,
+    EmptyObject,
+    ArmatureObject,
+    HairObject,
+    LatticeObject,
+    LightObject,
+    LightProbeObject,
+    MetaObject,
+    Material,
+    Texture,
+    Collection,
+    Image,
+    ViewLayer,
+    Asset,
+    World,
+)
+from .nodes import ProcNode, Shader, NodeDataType
+from .tracer import trace, autowrap_module, add_search_scope
+from .util.manifest import module_path
+
+autowrap_module(random)
+autowrap_module(color)
+add_search_scope(nodes)
+add_search_scope(ops)
+
+__all__ = [
+    # Subpackages
+    "compute_graph",
+    "control",
+    "context",
+    "color",
+    "nodes",
+    "ops",
+    "random",
+    "tracer",
+    "transforms",
+    "util",
+    # Node graph primitives
+    "ProcNode",
+    "Shader",
+    "NodeDataType",
+    # Tracing entrypoints
+    "trace",
+    # Utilities
+    "RNG",
+    "module_path",
+    # NOTE: Blender wrapper types (Object, MeshObject, Material, Texture, ...)
+    # are re-exported above for convenience but live in procfunc.types — see
+    # that page for documentation. Blender/mathutils re-exports (Vector, Color,
+    # Euler, Quaternion, Matrix, BVHTree, NodeGroup, Scene, ViewLayer) are
+    # likewise kept importable but documented upstream by Blender.
+]

procfunc-0.30.0/src/procfunc/color.py

@@ -0,0 +1,57 @@
+import numpy as np
+
+from procfunc import types as t
+
+
+def hsv_color(
+    hsv: np.ndarray | tuple | None = None,
+    *,
+    hue: float | None = None,
+    saturation: float | None = None,
+    value: float | None = None,
+) -> t.Color:
+    color = t.Color()
+    if hsv is not None:
+        color.hsv = hsv
+    else:
+        color.hsv = (hue, saturation, value)
+    return color
+
+
+hsv_to_rgba = hsv_color
+
+
+def rgb_color(
+    r: float | None = None,
+    g: float | None = None,
+    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
+
+
+def _srgb_to_linearrgb(c):
+    if c < 0:
+        return 0
+    elif c < 0.04045:
+        return c / 12.92
+    else:
+        return ((c + 0.055) / 1.055) ** 2.4
+
+
+def _hex_to_rgb(h: int, alpha: float = 1):
+    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

procfunc-0.30.0/src/procfunc/compute_graph/__init__.py

@@ -0,0 +1,28 @@
+from .compute_graph import (
+    ComputeGraph,
+)
+from .node import (
+    ConstantNode,
+    FunctionCallNode,
+    GetAttributeNode,
+    InputPlaceholderNode,
+    MethodCallNode,
+    MutatedArgumentNode,
+    Node,
+    ProceduralNode,
+    SubgraphCallNode,
+    normalize_args_to_kwargs,
+)
+from .operators_info import OperatorType
+from .proxy import AttributeProxy, Proxy
+from .util import (
+    LiteralConstant,
+    graph_nodes_equal,
+    transform_compute_graph,
+    transform_nodetree,
+    traverse_breadth_first,
+    traverse_depth_first,
+    traverse_depth_first_node,
+    traverse_nested_graphs,
+    usages_per_node,
+)

procfunc-0.30.0/src/procfunc/compute_graph/compute_graph.py

@@ -0,0 +1,115 @@
+import itertools
+import logging
+from dataclasses import dataclass
+from typing import Any
+
+from procfunc.util.pytree import PyTree
+
+from .node import Node
+
+logger = logging.getLogger(__name__)
+
+
+def _evaluate_node(node: Node) -> Any:
+    if node.result is not None:
+        return node.result
+
+    for arg in itertools.chain(node.args, node.kwargs.values()):
+        if isinstance(arg, Node):
+            arg.result = _evaluate_node(arg)
+
+    arg_eval, kwarg_eval = node.inputs.map(
+        lambda x: x.result if isinstance(x, Node) else x
+    ).obj()
+
+    # match node:
+    #     case cg.FunctionCallNode:
+    #         return node.func(*arg_vals, **kwarg_vals)
+    #     case cg.PlaceholderNode:
+    #         raise NotImplementedError(
+    #             f"Placeholder {node!r} or '<unnamed>'} should not be evaluated - "
+    #             "its .result should be populated in advance"
+    #         )
+    #     case cg.MutatedArgumentNode:
+    #         # Evaluate the mutation call first (for side effects), then return the original object
+    #         mutation_call_node = node.args[1]
+    #         _evaluate_node(mutation_call_node)
+    #         return (
+    #             node.args[0].result if isinstance(node.args[0], Node) else node.args[0]
+    #         )
+    #     case _:
+    #         raise NotImplementedError(f"Unsupported node operation: {node.kind}")
+
+
+def _clear_node_results(node: Node):
+    node.result = None
+    for arg in itertools.chain(node.args, node.kwargs.values()):
+        if isinstance(arg, Node) and arg.result is not None:
+            _clear_node_results(arg)
+
+
+@dataclass
+class ComputeGraph:
+    inputs: PyTree[Any, Node]
+    outputs: PyTree[Any, Node]
+    name: str
+    metadata: dict[str, Any]
+
+    def __post_init__(self):
+        # input_names = set(self.inputs.names())
+        # if len(input_names) != len(set(input_names)):
+        #     raise ValueError(f"Input names had duplicates: {input_names}")
+
+        # output_names = set(self.outputs.names())
+        # if len(output_names) != len(set(output_names)):
+        #     raise ValueError(f"Output names had duplicates: {output_names}")
+        pass
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}({self.name!r})"
+
+    def clear_values(self):
+        for node in self.outputs.values():
+            _clear_node_results(node)
+
+    def __call__(
+        self,
+        *args,
+        allow_clear: bool = True,
+        **kwargs,
+    ):
+        """
+        Execute the compute graph. If this graph came from a tracer,
+        this should be exactly equivelant to executing the original python function.
+        """
+
+        raise NotImplementedError("Not implemented")
+
+        if len(args) != len(self.inputs):
+            raise ValueError(f"Expected {len(self.inputs)} arguments, got {len(args)}")
+
+        if allow_clear:
+            self.clear_values()
+
+        extra_kwargs = self.kwarg_nodes.keys() - kwargs.keys()
+        if extra_kwargs:
+            raise ValueError(
+                f"{self.__class__.__name__} {self.name!r} got unexpected keyword arguments: {extra_kwargs}"
+            )
+
+        missing_kwargs = kwargs.keys() - self.kwarg_nodes.keys()
+        if missing_kwargs:
+            raise ValueError(
+                f"{self.__class__.__name__} {self.name!r} had missing keyword arguments: {missing_kwargs}"
+            )
+
+        for arg, arg_node in zip(args, self.arg_nodes):
+            arg_node.result = arg
+
+        for k, v in kwargs.items():
+            self.kwarg_nodes[k].result = v
+
+        for node in self.outputs.values():
+            _evaluate_node(node)
+
+        return {name: node.result for name, node in self.outputs.items()}