procfunc 0.30.0__py3-none-any.whl

procfunc/util/pytree.py

@@ -0,0 +1,343 @@
+import logging
+from dataclasses import dataclass
+from typing import Any, Callable, Generic, Iterator, TypeVar
+
+logger = logging.getLogger(__name__)
+
+"""
+A minimal pytree pack/unpack implementation inspired by JAX's docs.
+"""
+
+
+@dataclass
+class PyTreeDef:
+    container: type | None
+    items: list["PyTreeDef"]
+    aux: Any
+
+
+@dataclass
+class RegisteredPyTreeContainer:
+    flatten_func: Callable[[Any], tuple[list[Any], Any]]
+    unflatten_func: Callable[[list[Any], Any], Any]
+    names_func: Callable[[Any], list[str]]
+
+
+_registered_pytree_containers: dict[type, RegisteredPyTreeContainer] = {}
+
+
+TRegister = TypeVar("TRegister")
+
+
+def register_pytree_container(
+    container: type,
+    flatten_func: Callable[[TRegister], tuple[list[Any], Any]],
+    unflatten_func: Callable[[list[Any], Any], TRegister],
+    names_func: Callable[[TRegister], list[str]],
+):
+    _registered_pytree_containers[container] = RegisteredPyTreeContainer(
+        flatten_func,
+        unflatten_func,
+        names_func,
+    )
+
+
+def _tuple_flatten(obj: tuple) -> tuple[list[Any], Any]:
+    return list(obj), None
+
+
+def _tuple_unflatten(objs: list[Any], spec: Any) -> tuple:
+    return tuple(objs)
+
+
+def _list_flatten(obj: list) -> tuple[list[Any], Any]:
+    return obj, None
+
+
+def _list_unflatten(objs: list[Any], spec: Any) -> list:
+    return objs
+
+
+def _dict_flatten(obj: dict) -> tuple[list[Any], Any]:
+    return list(obj.values()), obj.keys()
+
+
+def _dict_unflatten(objs: list[Any], spec: Any) -> dict:
+    return dict(zip(spec, objs))
+
+
+def _namedtuple_flatten(obj: tuple) -> tuple[list[Any], Any]:
+    return list(obj), list(obj._fields)
+
+
+def _namedtuple_unflatten(objs: list[Any], spec: Any) -> tuple:
+    return spec.container(*objs)
+
+
+def _namedtuple_names(obj: tuple) -> list[str]:
+    return list(obj._fields)
+
+
+register_pytree_container(
+    list,
+    flatten_func=lambda x: (x, None),
+    unflatten_func=lambda x, spec: x,
+    names_func=lambda x: [str(i) for i in range(len(x))],
+)
+register_pytree_container(
+    dict,
+    flatten_func=lambda x: (list(x.values()), x.keys()),
+    unflatten_func=lambda x, spec: dict(zip(spec.aux, x)),
+    names_func=lambda x: list(x.keys()),
+)
+register_pytree_container(
+    tuple,
+    flatten_func=lambda x: (list(x), None),
+    unflatten_func=lambda x, spec: tuple(x),
+    names_func=lambda x: [str(i) for i in range(len(x))],
+)
+
+NAMEDTUPLE_CONTAINER = RegisteredPyTreeContainer(
+    flatten_func=_namedtuple_flatten,
+    unflatten_func=_namedtuple_unflatten,
+    names_func=_namedtuple_names,
+)
+
+
+def is_type_namedtuple(obj: type) -> bool:
+    return issubclass(obj, tuple) and obj is not tuple
+
+
+def is_obj_namedtuple(obj: Any) -> bool:
+    # theres no good way to check isinstance namedtuple
+    # namedtuple is a function not a type, and the returntype is only a subclass of tuple
+    return is_type_namedtuple(type(obj)) and hasattr(obj, "_fields")
+
+
+def flatten(obj: Any) -> tuple[list[Any], PyTreeDef]:
+    registered_pytree_container = _registered_pytree_containers.get(type(obj))
+
+    if registered_pytree_container is not None:
+        flatten_func = registered_pytree_container.flatten_func
+    elif is_obj_namedtuple(obj):
+        flatten_func = _namedtuple_flatten
+    else:
+        return [obj], PyTreeDef(None, [], None)
+
+    children, aux = flatten_func(obj)
+
+    child_items = []
+    spec_items = []
+    for child in children:
+        child_objs, child_spec = flatten(child)
+        child_items.extend(child_objs)
+        spec_items.append(child_spec)
+
+    return child_items, PyTreeDef(type(obj), spec_items, aux)
+
+
+def _get_container_funcs(container_type: type) -> RegisteredPyTreeContainer:
+    rec = _registered_pytree_containers.get(container_type)
+    if is_type_namedtuple(container_type):
+        return NAMEDTUPLE_CONTAINER
+    elif rec is None:
+        return None
+    else:
+        return rec
+
+
+def _unflatten_iterative(
+    children: Iterator[Any],
+    spec: PyTreeDef,
+) -> Any:
+    if spec.container is None:
+        return next(children)
+
+    container_spec = _get_container_funcs(spec.container)
+    if container_spec is None:
+        assert len(children) == 1
+        return next(children)
+
+    real_children = []
+    for child_spec in spec.items:
+        child = _unflatten_iterative(children, child_spec)
+        real_children.append(child)
+
+    return container_spec.unflatten_func(real_children, spec)
+
+
+def unflatten(children: list[Any], spec: PyTreeDef, start_idx: int = 0) -> Any:
+    return _unflatten_iterative(iter(children), spec)
+
+
+def _compute_pytree_obj_names(
+    obj: Any, separator: str = "_", nocontainer_name: str = ""
+) -> Iterator[str]:
+    container_spec = _get_container_funcs(type(obj))
+    if container_spec is None:
+        yield nocontainer_name
+        return
+    names = container_spec.names_func(obj)
+    children = container_spec.flatten_func(obj)[0]
+
+    for parentname, child in zip(names, children):
+        for childname in _compute_pytree_obj_names(child, separator):
+            yield (parentname + separator + childname if childname else parentname)
+
+
+TItem = TypeVar("TItem")
+TChildren = TypeVar("TChildren")
+TChildrenNew = TypeVar("TChildrenNew")
+
+
+class PyTree(Generic[TItem, TChildren]):
+    """
+    Data-structure for trees of python objects.Any
+
+    Pytrees support flattening and unflattening, similar to Jax
+
+    However, we additionally require that every registered pytree container provides names for each child.
+    """
+
+    def __init__(self, obj: TItem):
+        flat = flatten(obj)
+        self.children: list[TChildren] = flat[0]
+        self.spec: PyTreeDef = flat[1]
+
+    def __repr__(self):
+        return f"PyTree({self.spec!r}, len(children)={len(self.children)})"
+
+    def obj(self) -> TItem:
+        """Get the original object used to construct this PyTree"""
+
+        return unflatten(self.children, self.spec)
+
+    def dict(self) -> dict[str, TChildren]:
+        res = {}
+        for name, child in self.items():
+            if name in res:
+                existing = res[name]
+                raise ValueError(
+                    f"pytree to dict had duplicate key {name} for {existing=} and {child=}"
+                )
+            res[name] = child
+        return res
+
+    def values(self) -> Iterator[TChildren]:
+        return iter(self.children)
+
+    def names(self, separator: str = "_", nocontainer_name: str = "") -> Iterator[str]:
+        return _compute_pytree_obj_names(self.obj(), separator, nocontainer_name)
+
+    def items(
+        self, separator: str = "_", nocontainer_name: str = ""
+    ) -> Iterator[tuple[str, TChildren]]:
+        names = self.names(separator=separator, nocontainer_name=nocontainer_name)
+        return iter(zip(names, self.children))
+
+    def __len__(self) -> int:
+        return len(self.children)
+
+    @classmethod
+    def from_values(
+        cls, children: list[TChildren], spec: PyTreeDef
+    ) -> "PyTree[TItem, TChildren]":
+        return cls(unflatten(children, spec))
+
+    @classmethod
+    def from_children_spec(
+        cls, children: list[TChildren], spec: PyTreeDef
+    ) -> "PyTree[TItem, TChildren]":
+        res = PyTree(None)
+        res.children = children
+        res.spec = spec
+        return res
+
+    def map(
+        self, fn: Callable[[TChildren], TChildrenNew]
+    ) -> "PyTree[TItem, TChildrenNew]":
+        children = [fn(child) for child in self.children]
+        return self.from_values(children, self.spec)
+
+    def map_items(
+        self, fn: Callable[[str, TChildren], TChildrenNew]
+    ) -> "PyTree[TItem, TChildrenNew]":
+        children = [fn(name, child) for name, child in self.items()]
+        return self.from_values(children, self.spec)
+
+    def is_single(self) -> bool:
+        return self.spec.container is None
+
+    def toplevel_type(self) -> type:
+        return self.spec.container
+
+    def children_one_level(self) -> list[Any]:
+        obj = self.obj()
+
+        container_funcs = _get_container_funcs(self.spec.container)
+
+        child_objs = container_funcs.flatten_func(obj)[0]
+        new_children = []
+        for child_obj, child_spec in zip(child_objs, self.spec.items):
+            if child_spec.container is not None:
+                child_tree = PyTree(child_obj)
+                new_children.append(child_tree)
+            else:
+                new_children.append(child_obj)
+
+        return new_children
+
+    def unflatten_one_level(
+        self,
+    ) -> TItem:
+        container_funcs = _get_container_funcs(self.spec.container)
+        return container_funcs.unflatten_func(self.children_one_level(), self.spec)
+
+    def value(self) -> TItem:
+        return unflatten(self.children, self.spec)
+
+
+def repr_tree_to_str(
+    tree: PyTree[Any, str] | str,
+    type_namer: Callable[[type], str] | None = None,
+) -> str:
+    if type_namer is None:
+
+        def type_namer(t):
+            return t.__name__
+
+    if isinstance(tree, str):
+        return tree
+
+    if tree.spec.container is None or tree.spec.container is type(None):
+        assert len(tree.children) == 1, tree.children
+        assert isinstance(tree.children[0], str)
+        return tree.children[0]
+
+    children = tree.children_one_level()
+    childreprs = [repr_tree_to_str(child, type_namer) for child in children]
+
+    if tree.spec.container is list:
+        return f"[{', '.join(childreprs)}]"
+    elif tree.spec.container is dict:
+        keys = list(tree.unflatten_one_level().keys())
+        return (
+            "{" + ", ".join(f"{repr(k)}: {v}" for k, v in zip(keys, childreprs)) + "}"
+        )
+    elif tree.spec.container is tuple:
+        return f"({', '.join(childreprs)})"
+    elif is_type_namedtuple(tree.spec.container):
+        return f"{type_namer(tree.spec.container)}({', '.join(childreprs)})"
+    elif tree.spec.container in _registered_pytree_containers:
+        container_funcs = _registered_pytree_containers[tree.spec.container]
+        names = container_funcs.names_func(None)
+        return f"{type_namer(tree.spec.container)}({', '.join(f'{n}={v}' for n, v in zip(names, childreprs))})"
+    else:
+        raise ValueError(f"Unsupported container type {tree.spec.container}")
+
+
+__all__ = [
+    "flatten",
+    "unflatten",
+    "PyTree",
+]

procfunc/util/teardown.py

@@ -0,0 +1,37 @@
+"""Helpers to exit without triggering bpy's C-level teardown segfault.
+
+bpy's cleanup segfaults (SIGSEGV / exit code 139) during normal Python
+shutdown. ``os._exit`` skips Python teardown and atexit handlers, avoiding
+the crash while preserving the real exit code.
+"""
+
+import os
+import sys
+import traceback
+from contextlib import contextmanager
+
+
+def exit_skipping_teardown(code: int = 0):
+    sys.stdout.flush()
+    sys.stderr.flush()
+    os._exit(code)
+
+
+@contextmanager
+def skip_teardown_on_exit():
+    """Run a block and unconditionally ``os._exit`` when it finishes.
+
+    Catches ``SystemExit``, unhandled exceptions, and normal return;
+    translates each into an ``os._exit`` with the appropriate code so
+    bpy's teardown is skipped. Unhandled exceptions are printed with the
+    standard Python traceback format to stderr before exiting, matching
+    what you'd see from a natural crash.
+    """
+    try:
+        yield
+    except SystemExit as e:
+        exit_skipping_teardown(e.code if isinstance(e.code, int) else 1)
+    except BaseException:
+        traceback.print_exc()
+        exit_skipping_teardown(1)
+    exit_skipping_teardown(0)

procfunc-0.30.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,76 @@
+procfunc/__init__.py,sha256=-hCx5Edtijw2i3wXYWlqqPZ58VUH2LKwSzGBcJvnoYU,1826
+procfunc/color.py,sha256=oae7WRSU3J0Tz-fC_NYX8_qMSvcu2nAoAY4cGILOAyU,1175
+procfunc/context.py,sha256=51td0Vkpyyjjh9SgLMcAycS9KdNdC6J0ipCFGU7FkEs,4233
+procfunc/control.py,sha256=ZmBHEnIdd1hmFSr_nXLznkhfZrO-nUUY2DnlRD1Ow0I,5138
+procfunc/random.py,sha256=1N4GT_PLIUcI0OGLqYH3cIddHm2rLrTgX16sXVr7rzg,4776
+procfunc/types.py,sha256=tupPzIj2oih5pBvfm_KrvBA0W9TbuGiXi3sFP5sayJY,10592
+procfunc/compute_graph/__init__.py,sha256=sMDY97qqaIkDd0EHxXMIuMEbfptSu7caUYV8A4pRxPU,621
+procfunc/compute_graph/compute_graph.py,sha256=UEKxNnwtT8W9pS95mRkAdcYDJo0rbEJ7o9c4B41s3YQ,3675
+procfunc/compute_graph/node.py,sha256=-2DYDiDhrFdWQZQufCFeWvHhjHyCRJA00pTVUbLeYvU,6065
+procfunc/compute_graph/operators_info.py,sha256=GGYXQgae8PBgLQSiD2ICxqlZsfVwj5bA_bfKl7zSIDg,2448
+procfunc/compute_graph/proxy.py,sha256=68H-CHlTZumhN6hUMqCUfXVohRYxi3QfmDdWIvO0mRc,5145
+procfunc/compute_graph/util.py,sha256=6Lvp5M9ryCjP2M0BfT3wuxYjCn1R0d2vCLPwSVXyW8w,7886
+procfunc/nodes/__init__.py,sha256=l3O5TqL5URZlST7ojdG3Uxgb076n_aDZDFkNZvXgXO4,1592
+procfunc/nodes/bindings_util.py,sha256=YFmqwoIccs9iB7sxJaE7-92PeqRV2jP72oXrXU7i1p4,6727
+procfunc/nodes/bpy_node_info.py,sha256=TrrT6_uac8pD69rTrvPUOGo6TPgAFeW6nz4frO3liIU,8225
+procfunc/nodes/compositor.py,sha256=G-yOGOUAIagIVKQW5BNCE3PNkaj_zc-ZCZBrY9lhJn8,64784
+procfunc/nodes/func.py,sha256=guPkyhRHT6IDJP-IoJA0KRz7t_4nd_Q0s5IqnscZQyc,41021
+procfunc/nodes/geo.py,sha256=GMRfNt7wCyAwfml_JggEPKcMSU10wRNMtyvXNJfJwaM,129731
+procfunc/nodes/manifest.json,sha256=w33_d5NdbgnxSdK5qINDGxutCAVveayUFUA4YrueGOY,224587
+procfunc/nodes/math.py,sha256=-sVHfCgF_gOHEqA8yS-1lM5lpXR2FslRMpDJXxWSq7Y,18566
+procfunc/nodes/node_function.py,sha256=158JoMW8trrVLskHin1L1tI2Bf_PMWvEmPjn2aohGV0,5195
+procfunc/nodes/shader.py,sha256=gR4Qp09vSpCLB95t7lC9-QmVzFlJvCRjWLoNo_18S2s,73564
+procfunc/nodes/types.py,sha256=dfj3-l4sBvAAxRcjYvoNfUM5l0lRlZ_goJO5XplH0RY,11529
+procfunc/nodes/execute/construct_nodes.py,sha256=oq5Ju75t-voAXO4maix2WlZ14UDKsBS8TB9I_D61qE0,20083
+procfunc/nodes/execute/construct_special_cases.py,sha256=kXfA8Uo3iKJHmeUpHM14njBT_bxB0wxTAEHjKO4ZcRQ,7668
+procfunc/nodes/execute/execute.py,sha256=tnbzpKiVClrGBg1tXYFdOgZOyiufK7z_wG_z8NjrC2U,17143
+procfunc/nodes/execute/infer_runtime_data_type.py,sha256=C1L5C7d2ZdFzYVXeN1MXPPkmRycaRf6cCQMDudAxKTc,6572
+procfunc/nodes/execute/util.py,sha256=2BZKxUCZb9vzoE7vVWwlXmgXzauXPRH2s0ZvjXzJ4OI,8644
+procfunc/ops/__init__.py,sha256=XwD9FIArPEkJ38CEdx2GvVCnXriCmEo7RJ9sT-d_fV0,580
+procfunc/ops/_util.py,sha256=QcBZJ470n9ZV6YWSpj8P4u8_25MbGwpb7r6Ta8m2fpU,8018
+procfunc/ops/addons.py,sha256=z1tlA9GqsBkldQib8EvFC1JaKHn3YqtD5b7WMBoux9k,1906
+procfunc/ops/attr.py,sha256=Q7r9Jj7dBxHAUz74V3dG4sEghw7Y-Y08_-YhargOP7E,13383
+procfunc/ops/collection.py,sha256=zwLBxvE_D7FqGf_Dq0pSto2dUeUaww_io8zciB8m6vs,2560
+procfunc/ops/curve.py,sha256=LXCN_ANEcCawjC2Som4BcMEQXigFqlIjDWrBIlek3_U,400
+procfunc/ops/file.py,sha256=e5DTwVDY0BueGI_3pp1Dhr0Ki_V55W6P5OedAYowrW4,3631
+procfunc/ops/manifest.json,sha256=ZRAwPd6077ndNdeLDNVZbgMzuTr7vaTITx_OfM-ADU4,1099302
+procfunc/ops/mesh.py,sha256=eiqpdJaayVRV-ubKPbc0YN-CC18yaUoHGG9vwexkAaA,42716
+procfunc/ops/modifier.py,sha256=IdPL5_FyiUg5N-qZwEsN8oOggCzxDQi4kI3yv3oiCFU,15688
+procfunc/ops/object.py,sha256=sZ6icCXd-uybMMFeniZVM6yuVzJ_LyTLnFJCIlPtsBU,7173
+procfunc/ops/uv.py,sha256=xRYmPIxoyBQvg2InwQcE_sKrQilYrbTVjdtsYDUxu2k,8514
+procfunc/ops/primitives/__init__.py,sha256=0HWtXy2nsAeeVVV-uV-vOFHwsJ1n4Nhwq_iChB4Fxxg,492
+procfunc/ops/primitives/camera.py,sha256=X3hNwvVkCMVZyXp-qIGlJAUbFip3WsL-P4TK64bKY3Y,1246
+procfunc/ops/primitives/curve.py,sha256=AptzFWxqgGS_xhVmy0n18pZtZ9lzLZvPhpTQxiTsEeQ,2279
+procfunc/ops/primitives/light.py,sha256=v6AL48m6TVz_vQD0qFBZhA0PO1QNAZEkEOfX91B_a4Q,3651
+procfunc/ops/primitives/mesh.py,sha256=tuPZ6jMW7hejIrIRnaSxF6X-Wah8-eDTwvDEPbV2Zxk,10019
+procfunc/tracer/__init__.py,sha256=m1XdoNp37CKHhgAkuC_Kh_IFUI4uhhj8K_5W9rsaEdQ,798
+procfunc/tracer/decorator.py,sha256=gjdHuSe68-_y4kUxqRYi3_OXx0o0rPNx08Pb-S9AV3c,3806
+procfunc/tracer/patch.py,sha256=PzTPjpdhuk9USndCoAjGzeVFFVBP7k9YOyUcXaJQARI,17051
+procfunc/tracer/proxy.py,sha256=BQMyLuLsHs0p5Qhf1bEvtmEYGfMMAKnbE7UmJ1jBe9c,3664
+procfunc/tracer/trace.py,sha256=tRCQOSfv35PMYA8ZjXpocz-gEb_XOY4ivu58duXfE3E,6074
+procfunc/transforms/__init__.py,sha256=5OPkJFds2qNz3tydQxbY-bst7M_6wD_uqSSSErOQ25c,1243
+procfunc/transforms/cleanup.py,sha256=aoilB72ZCkfa_0Q41PNC_P3ZeeziqMFVVCMdBp6tfso,6629
+procfunc/transforms/convert.py,sha256=YdQEQp9qK6l9o7qGWPPHm4hFeJXgIaWNUkhHLjFCl2s,779
+procfunc/transforms/distribution.py,sha256=kB85-XrLBDKb7MnYpjd816wLUinbrv77cVYLQLInZyE,6586
+procfunc/transforms/extract_materials.py,sha256=hPjYoS5qghvKx75CcBcKVtyZOL07ukukkdFodDUThtM,3768
+procfunc/transforms/infer_distribution.py,sha256=-AZP_H5YIU2sIn9nvasenrsQcrBKlGa3dCZTyz9aEGY,10642
+procfunc/transforms/parameters.py,sha256=wRKzCKH6FKZTLRdrt8X9GN2JAOJH_r5V7H98eo72h_8,432
+procfunc/transforms/util.py,sha256=D4fdLn0TfLmyLzosLnvyk7ElUKuHW2rVMJ_ytQmrwhk,1127
+procfunc/transpiler/__init__.py,sha256=V_SvwphTm01awck4afJkI8v1jwbm66DR9jEZAEjpGyQ,451
+procfunc/transpiler/bpy_to_computegraph.py,sha256=T-fOpRJYz_iVrH-9mC6w3Z5nKSRrTUcs5xkWqSgyBZ0,45369
+procfunc/transpiler/codegen.py,sha256=HxIpcdaic-TusZ7NSKW4bIhOTXeRa_wIneKYgi9oa8k,30793
+procfunc/transpiler/identifiers.py,sha256=F14q_tz2Mzl6HvdL5hoqVloyYY9dcyE1U9DXh-I30Lg,18715
+procfunc/transpiler/main.py,sha256=eDlct7T-ad6gbncbr7zrjQdW8OyflR5FmWg13HBSP_8,8938
+procfunc/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+procfunc/util/bpy_info.py,sha256=z2mRLgmYJalnBOXVJRjmbCf3HtDPa0sfdaG2FWUBDzA,3616
+procfunc/util/camera.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+procfunc/util/keyframe.py,sha256=BkzvwlblstIR_HweCLnqbunnxyQKwbR83rf6W62E6Eo,2234
+procfunc/util/log.py,sha256=Z8_FG0sLrbS6FP1GHuup4ZCdK01wLfkjCARz8t1xEjw,2513
+procfunc/util/manifest.py,sha256=gHcwd6XA3SEsqTzds_9EK74DZY1RpZ1mqv6Z1Pc0Vt8,3857
+procfunc/util/pytree.py,sha256=xz9rBQdYZWBpKG7jNirawnr3dE1O8pFEECk4EcMB3m4,10163
+procfunc/util/teardown.py,sha256=tw9wxZxBdLvhf4v8PIiimKGR4vjH7IFpb2MIEllASAo,1151
+procfunc-0.30.0.dist-info/licenses/LICENSE.md,sha256=rbHE2JmP9dBt-KDoOW-L6ezvPDvpKzlk5z3UNTngySk,1468
+procfunc-0.30.0.dist-info/METADATA,sha256=hDaoy4V82m5fPy23rwjIqtH34KilKE9-jAw0OorSPRU,4383
+procfunc-0.30.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+procfunc-0.30.0.dist-info/top_level.txt,sha256=VDI0XXM5U6uKHLV036b2k7PYhYEBNFtHuM5WyUp2RWU,9
+procfunc-0.30.0.dist-info/RECORD,,

procfunc-0.30.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

procfunc-0.30.0.dist-info/licenses/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.dist-info/top_level.txt

@@ -0,0 +1 @@
+procfunc