procfunc 0.30.2__tar.gz → 0.33.0__tar.gz

{procfunc-0.30.2/src/procfunc.egg-info → procfunc-0.33.0}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: procfunc
-Version: 0.30.2
+Version: 0.33.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
 Project-URL: Repository, https://github.com/princeton-vl/procfunc
-Requires-Python: >=3.11
+Requires-Python: <3.12,>=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE.md
 Requires-Dist: bpy==4.2.0
@@ -19,13 +19,13 @@ Requires-Dist: ty; extra == "dev"
 Provides-Extra: docs
 Requires-Dist: sphinx; extra == "docs"
 Requires-Dist: sphinx-rtd-theme; extra == "docs"
+Requires-Dist: sphinx-argparse; extra == "docs"
 Dynamic: license-file
 
 # ProcFunc: Function-Oriented Abstractions for Procedural 3D Generation in Python
 
 [**Documentation**](#documentation)
 | [**Research Paper**](https://arxiv.org/abs/2604.26943)
-| [**Documentation**](https://procfunc.readthedocs.io)
 | [**Transpiling**](#transpile-a-blender-file-to-procfunc-code)
 | [**Experiments**](#experiments)
 | [**Contributing**](#contributing)
@@ -62,7 +62,7 @@ Please create Github Issues for any bugs or  unclear interfaces!
 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
+uv run procfunc transpile 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).

{procfunc-0.30.2 → procfunc-0.33.0}/README.md

@@ -2,7 +2,6 @@
 
 [**Documentation**](#documentation)
 | [**Research Paper**](https://arxiv.org/abs/2604.26943)
-| [**Documentation**](https://procfunc.readthedocs.io)
 | [**Transpiling**](#transpile-a-blender-file-to-procfunc-code)
 | [**Experiments**](#experiments)
 | [**Contributing**](#contributing)
@@ -39,7 +38,7 @@ Please create Github Issues for any bugs or  unclear interfaces!
 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
+uv run procfunc transpile 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).

{procfunc-0.30.2 → procfunc-0.33.0}/pyproject.toml

@@ -4,11 +4,11 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "procfunc"
-version = "0.30.2"
+dynamic = ["version"]
 description = "Function-Oriented Abstractions for Procedural 3D Generation in Python"
 readme = "README.md"
 license = "BSD-3-Clause"
-requires-python = ">=3.11"
+requires-python = ">=3.11,<3.12"
 dependencies = [
     "bpy==4.2.0",
     "numpy<2",
@@ -19,6 +19,9 @@ dependencies = [
 Homepage = "https://github.com/princeton-vl/procfunc"
 Repository = "https://github.com/princeton-vl/procfunc"
 
+[project.scripts]
+procfunc = "procfunc.cli:cli"
+
 [project.optional-dependencies]
 dev = [
     "pytest",
@@ -29,8 +32,12 @@ dev = [
 docs = [
     "sphinx",
     "sphinx-rtd-theme",
+    "sphinx-argparse",
 ]
 
+[tool.setuptools.dynamic]
+version = {attr = "procfunc.__version__"}
+
 [tool.setuptools.packages.find]
 where = ["src"]
 

{procfunc-0.30.2 → procfunc-0.33.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.30.2"
+__version__ = "0.33.0"
 
 from numpy.random import Generator as RNG
 
@@ -41,6 +41,7 @@ from .types import (
     LightObject,
     LightProbeObject,
     MetaObject,
+    PointCloudObject,
     Material,
     Texture,
     Collection,

procfunc-0.33.0/src/procfunc/cli/__init__.py

@@ -0,0 +1,3 @@
+from procfunc.cli.main import cli
+
+__all__ = ["cli"]

procfunc-0.33.0/src/procfunc/cli/main.py

@@ -0,0 +1,35 @@
+import argparse
+
+from procfunc.transpiler import main as transpiler_main
+from procfunc.util.teardown import skip_teardown_on_exit
+
+
+def get_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="procfunc")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    transpile_parser = subparsers.add_parser(
+        "transpile", help="Transpile a Blender file to procfunc Python code."
+    )
+    transpiler_main.add_transpile_arguments(transpile_parser)
+
+    return parser
+
+
+def main():
+    parser = get_parser()
+    args = parser.parse_args()
+
+    if args.command == "transpile":
+        transpiler_main.run(args)
+    else:
+        parser.error(f"Unknown command: {args.command}")
+
+
+def cli():
+    with skip_teardown_on_exit():
+        main()
+
+
+if __name__ == "__main__":
+    cli()

procfunc-0.33.0/src/procfunc/codegen/__init__.py

@@ -0,0 +1,8 @@
+from .codegen import default_func_resolution_map, to_python
+from .identifiers import dedup_names_with_suffix
+
+__all__ = [
+    "default_func_resolution_map",
+    "to_python",
+    "dedup_names_with_suffix",
+]

{procfunc-0.30.2/src/procfunc/transpiler → procfunc-0.33.0/src/procfunc/codegen}/codegen.py

@@ -5,19 +5,19 @@ import itertools
 import logging
 from collections import OrderedDict, defaultdict
 from pathlib import Path
-from typing import Any, Callable, Generator, Union, get_args, get_origin
+from typing import Any, Callable, Generator
 
 import numpy as np
 
 import procfunc as pf
 from procfunc import compute_graph as cg
+from procfunc.codegen import identifiers
+from procfunc.codegen.repr import repr_type, repr_value
 from procfunc.compute_graph.operators_info import (
     FUNCTIONS_TO_OPERATORS,
     OPERATOR_TEMPLATES,
     OperatorType,
 )
-from procfunc.nodes import types as nt
-from procfunc.transpiler import identifiers
 from procfunc.util import pytree
 
 logger = logging.getLogger(__name__)
@@ -29,92 +29,6 @@ def indent_lines(lines: list[str], indent: str = INDENT) -> list[str]:
     return [indent + line for line in lines]
 
 
-def _repr_type(x: Any) -> str:
-    # TODO: make the user pass in special resolutions for types, or else we will just do verbose types
-
-    if isinstance(x, str):
-        return x
-
-    if x.__name__ == "NoneType":
-        return "None"
-
-    origin = get_origin(x)
-    args = get_args(x)
-
-    if x.__name__ == "ProcNode":
-        if len(args) == 1:
-            return f"pf.ProcNode[{_repr_type(args[0])}]"
-        elif len(args) == 0:
-            return "pf.ProcNode"
-        else:
-            raise ValueError(f"Unsupported ProcNode type: {x} {args=}")
-
-    if hasattr(pf, x.__name__):
-        if len(args):
-            raise ValueError(f"procfunc type had unhandled annotations: {x} {args=}")
-        return f"pf.{x.__name__}"
-
-    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__}"
-
-    return x.__name__
-
-
-def _repr_value(value: Any) -> str:
-    if hasattr(value, "__wrapped__"):
-        value = value.__wrapped__
-
-    if isinstance(value, cg.Proxy):
-        logger.warning(
-            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(
-            f"Procnode object {value} should never be treated as a raw value in codegen"
-        )
-
-    if isinstance(value, np.random.Generator):
-        return "np.random.default_rng()"
-    elif isinstance(value, type):
-        return _repr_type(value)
-    elif isinstance(value, np.ndarray):
-        nprepr = repr(value).replace("\n", "")
-        return f"np.{nprepr}"
-    elif isinstance(value, np.dtype):
-        return f"np.dtype('{value}')"
-    elif isinstance(value, (pf.Color, pf.Vector, pf.Euler, pf.Quaternion, pf.Matrix)):
-        x = tuple(round(x, 6) for x in value)
-        return f"pf.{value.__class__.__name__}({x})"
-    elif isinstance(value, enum.Enum):
-        return f"{type(value).__name__}.{value.name}"
-    elif isinstance(value, Path):
-        return f"Path({str(value)!r})"
-    elif dataclasses.is_dataclass(value) and not isinstance(value, type):
-        args_str = ", ".join(
-            f"{f.name}={_repr_value(getattr(value, f.name))}"
-            for f in dataclasses.fields(value)
-        )
-        return f"{type(value).__name__}({args_str})"
-    elif isinstance(value, list):
-        return f"[{', '.join([_repr_value(x) for x in value])}]"
-    else:
-        return repr(value)
-
-
 def _repr_inp(
     arg: Any,
     scope_expressions: dict[int, str | list[str]],
@@ -127,7 +41,7 @@ def _repr_inp(
             )
         expr = scope_expressions[id(arg)]
     else:
-        expr = _repr_value(arg)
+        expr = repr_value(arg)
 
     if isinstance(expr, list):
         if len(expr) > 1:
@@ -184,7 +98,7 @@ def _repr_args(
 
     argreprs = pytree.PyTree(args).map(lambda x: _repr_inp(x, scope_expressions))
     argreprs = [
-        pytree.repr_tree_to_str(v, type_namer=_repr_type)
+        pytree.repr_tree_to_str(v, type_namer=repr_type)
         for v in argreprs.unflatten_one_level()
     ]
 
@@ -194,7 +108,7 @@ def _repr_args(
         .unflatten_one_level()
     )
     kwargreprs = {
-        k: pytree.repr_tree_to_str(v, type_namer=_repr_type)
+        k: pytree.repr_tree_to_str(v, type_namer=repr_type)
         for k, v in kwargreprs.items()
     }
 
@@ -222,11 +136,12 @@ def _repr_function_call(
     node: cg.FunctionCallNode | cg.MethodCallNode | cg.SubgraphCallNode,
     scope_expressions: dict[int, str | list[str]],
     line_limit: int = 80,
+    func_str: str | None = None,
 ) -> list[str]:
     match node:
         case cg.FunctionCallNode():
             func = node.func
-            func_str = scope_expressions[id(func)]
+            func_str = func_str or scope_expressions[id(func)]
         case cg.MethodCallNode(args=(target, *_), method_name=method_name):
             if not isinstance(target, cg.Node):
                 raise ValueError(f"Method call {node=} has non-node target {target=}")
@@ -261,22 +176,44 @@ def _repr_function_call(
         return [f"{func_str}({', '.join(arg_reprs)})"]
 
 
-def _repr_operator_call(
+def _operator_call_operands(
     node: cg.FunctionCallNode,
+    template: str,
+) -> list | None:
+    """Operand values for rendering `node` in infix/operator form, or None to
+    decline it. The operator template only has slots for the operands, so any
+    extra argument beyond them (e.g. a non-default epsilon on func.equal) would
+    be silently dropped by the infix form - decline unless it merely restates
+    the signature default, in which case it is redundant and dropped."""
+    n_slots = template.count("{}")
+    try:
+        sig = inspect.signature(node.func)
+        bound = sig.bind(*node.args, **node.kwargs)
+    except (TypeError, ValueError):
+        return None
+
+    operand_names = list(sig.parameters)[:n_slots]
+    if any(name not in bound.arguments for name in operand_names):
+        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]
+
+
+def _repr_operator_call(
+    operands: list,
+    template: str,
     scope_expressions: dict[int, str | list[str]],
 ) -> list[str]:
-    assert isinstance(node, cg.FunctionCallNode), node
-
-    # Support both positional args and kwargs for operator templates
-    all_args = [
-        _repr_inp(v, scope_expressions, extra_parens=True) for v in node.args
-    ] + [
-        _repr_inp(v, scope_expressions, extra_parens=True) for v in node.kwargs.values()
+    operand_reprs = [
+        _repr_inp(v, scope_expressions, extra_parens=True) for v in operands
     ]
-
-    operator_template = scope_expressions[id(node.func)]
-    assert isinstance(operator_template, str), operator_template
-    return [operator_template.format(*all_args)]
+    return [template.format(*operand_reprs)]
 
 
 def _codegen_for_node(
@@ -293,7 +230,17 @@ def _codegen_for_node(
             elif funcres == OperatorType.NOOP:
                 return []  # no code needed
             elif "{}" in funcres:
-                return _repr_operator_call(node, scope_expressions)
+                operands = _operator_call_operands(node, funcres)
+                if operands is None:
+                    # args the infix form cannot express: emit a named call.
+                    # scope_expressions holds the operator template, so re-derive
+                    # the callsite name (import already present via
+                    # default_func_resolution_map)
+                    _, callsite = _resolve_func(func)
+                    return _repr_function_call(
+                        node, scope_expressions, func_str=callsite
+                    )
+                return _repr_operator_call(operands, funcres, scope_expressions)
             else:
                 return _repr_function_call(node, scope_expressions)
         case cg.MethodCallNode() if node.method_name == "__getitem__":
@@ -320,7 +267,7 @@ def _codegen_for_node(
                 )
             return [f"{arg_expr}.{attribute_name}"]
         case cg.ConstantNode(value=value):
-            return [_repr_value(value)]
+            return [repr_value(value)]
         case _:
             raise TypeError(f"Unsupported {node=}")
 
@@ -353,17 +300,17 @@ def _codegen_graph_inputs(
 
         known_value_type = node.metadata.get("known_value_type", None)
         line = (
-            f"{name}: {_repr_type(known_value_type)}"
+            f"{name}: {repr_type(known_value_type)}"
             if known_value_type is not None
             else f"{name}"
         )
 
         if (default := node.kwargs.get("default_value")) is not None:
-            line += f" = {_repr_value(default)}"
+            line += f" = {repr_value(default)}"
 
         args_lines.append(line + ",")
 
-    end_statement = "):" if typename is None else f") -> {typename}: "
+    end_statement = "):" if typename is None else f") -> {typename}:"
 
     return [f"def {func_name}("] + indent_lines(args_lines) + [end_statement]
 
@@ -379,7 +326,7 @@ def _codegen_namedtuple_def(outputs: pytree.PyTree):
         if vt is None:
             type_lines.append(f"{name}: Any")
         else:
-            type_lines.append(f"{name}: {_repr_type(vt)}")
+            type_lines.append(f"{name}: {repr_type(vt)}")
 
     return [f"class {tupletype.__name__}(NamedTuple):"] + indent_lines(type_lines)
 
@@ -389,15 +336,17 @@ def _codegen_for_outputs(
     scope_expressions: dict[int, str | list[str]],
 ) -> tuple[str | None, list[str], list[str]]:
     if len(graph.outputs) == 0:
-        return None, [], []
+        # Sink graphs (no return values) still need a body statement so the
+        # generated function parses; emit `pass` when nothing else fills it.
+        return None, [], ["pass"]
     if len(graph.outputs) == 1:
         single_output = next(graph.outputs.values())
         vt = single_output.metadata.get("known_value_type", None)
-        type_name = _repr_type(vt) if vt is not None else None
+        type_name = repr_type(vt) if vt is not None else None
         return type_name, [], [f"return {_repr_inp(single_output, scope_expressions)}"]
 
     graph_output_type = graph.outputs.toplevel_type()
-    type_name = _repr_type(graph_output_type)
+    type_name = repr_type(graph_output_type)
 
     is_pf_type = hasattr(pf, graph_output_type.__name__)
     if is_pf_type:
@@ -416,7 +365,7 @@ def _codegen_for_outputs(
 
     reprs_tree = graph.outputs.map(lambda node: _repr_inp(node, scope_expressions))
     return_lines = [
-        f"return {pytree.repr_tree_to_str(reprs_tree, type_namer=_repr_type)}"
+        f"return {pytree.repr_tree_to_str(reprs_tree, type_namer=repr_type)}"
     ]
 
     return type_name, type_def, return_lines
@@ -572,6 +521,7 @@ def _code_paragraphing_predicate(
 def _codegen_for_assignment(
     assign_varname: str,
     node_code: list[str] | str,
+    node: cg.Node,
     add_line_comments: bool,
 ) -> list[str]:
     assert isinstance(assign_varname, str)
@@ -582,7 +532,7 @@ def _codegen_for_assignment(
     else:
         node_code = [f"{assign_varname} = {node_code}"]
     if add_line_comments:
-        node_code[0] += f" # {node}"  # noqa: F821
+        node_code[-1] += f"  # {str(node).replace(chr(10), ' ')}"
 
     return node_code
 
@@ -662,7 +612,7 @@ def _codegen_for_graph(
             continue
 
         varname = expressions[id(node)]
-        node_code = _codegen_for_assignment(varname, node_code, add_line_comments)
+        node_code = _codegen_for_assignment(varname, node_code, node, add_line_comments)
         code_lines.extend(node_code)
 
         if last_varname.split("_")[0] != varname.split("_")[0]:
@@ -720,7 +670,7 @@ def default_func_resolution_map(
     skip_funcs: set | None = None,
 ) -> tuple[dict[Any, str | OperatorType], list[str]]:
     func_resolution = {}
-    import_lines = set()
+    import_lines = {"import procfunc as pf"}
 
     for graph in cg.traverse_nested_graphs(toplevel_graph):
         assert isinstance(graph, cg.ComputeGraph), graph
@@ -771,43 +721,46 @@ def graphs_to_python_functions(
     np_linewidth = np.get_printoptions()["linewidth"]
     np.set_printoptions(linewidth=100000)
 
-    targets = _topo_sort_subgraphs(graph)
+    try:
+        targets = _topo_sort_subgraphs(graph)
 
-    def _clean_graph_name(name: str) -> str:
-        for suffix in identifiers.NONDESCRIPTIVE_NODE_NAME_PARTS:
-            if name.endswith("_" + suffix):
-                name = name[: -(len(suffix) + 1)]
-        return name
+        def _clean_graph_name(name: str) -> str:
+            for suffix in identifiers.NONDESCRIPTIVE_NODE_NAME_PARTS:
+                if name.endswith("_" + suffix):
+                    name = name[: -(len(suffix) + 1)]
+            return name
 
-    for subgraph in cg.traverse_nested_graphs(graph):
-        subgraph.name = _clean_graph_name(subgraph.name)
+        for subgraph in cg.traverse_nested_graphs(graph):
+            subgraph.name = _clean_graph_name(subgraph.name)
 
-    subgraph_names = {
-        id(subgraph): subgraph.name for subgraph in cg.traverse_nested_graphs(graph)
-    }
-    subgraph_names = identifiers.dedup_names_with_suffix(subgraph_names, separator="_")
-
-    scope_expressions = subgraph_names.copy()
-    for k, v in func_resolution.items():
-        if isinstance(v, OperatorType):
-            scope_expressions[id(k)] = OPERATOR_TEMPLATES[v]
-        else:
-            scope_expressions[id(k)] = v
-
-    lines_for_modules = []
-    for subgraph in targets:
-        func_name = subgraph_names[id(subgraph)]
-        result = _codegen_for_graph(
-            subgraph,
-            scope_expressions=scope_expressions.copy(),
-            as_maincall=(subgraph is graph and toplevel_as_maincall),
-            add_version_comment=add_version_comment,
-            add_line_comments=add_line_comments,
-            func_name=func_name,
+        subgraph_names = {
+            id(subgraph): subgraph.name for subgraph in cg.traverse_nested_graphs(graph)
+        }
+        subgraph_names = identifiers.dedup_names_with_suffix(
+            subgraph_names, separator="_"
         )
-        lines_for_modules.append((subgraph_names[id(subgraph)], result))
 
-    np.set_printoptions(linewidth=np_linewidth)
+        scope_expressions = subgraph_names.copy()
+        for k, v in func_resolution.items():
+            if isinstance(v, OperatorType):
+                scope_expressions[id(k)] = OPERATOR_TEMPLATES[v]
+            else:
+                scope_expressions[id(k)] = v
+
+        lines_for_modules = []
+        for subgraph in targets:
+            func_name = subgraph_names[id(subgraph)]
+            result = _codegen_for_graph(
+                subgraph,
+                scope_expressions=scope_expressions.copy(),
+                as_maincall=(subgraph is graph and toplevel_as_maincall),
+                add_version_comment=add_version_comment,
+                add_line_comments=add_line_comments,
+                func_name=func_name,
+            )
+            lines_for_modules.append((subgraph_names[id(subgraph)], result))
+    finally:
+        np.set_printoptions(linewidth=np_linewidth)
 
     return OrderedDict(lines_for_modules)
 

{procfunc-0.30.2/src/procfunc/transpiler → procfunc-0.33.0/src/procfunc/codegen}/identifiers.py

@@ -1,3 +1,4 @@
+import keyword
 import logging
 import re
 from collections import Counter, defaultdict
@@ -36,6 +37,10 @@ def bpy_name_to_pythonid(name: str) -> str:
 
     name = name.lower()
 
+    # drop anything that isn't valid in a python identifier (e.g. parentheses
+    # in socket names like "Joint ID (do not set)")
+    name = re.sub(r"[^0-9a-z_]", "_", name)
+
     name = re.sub(r"_+", "_", name).strip("_")
 
     # move number terms to end
@@ -46,6 +51,9 @@ def bpy_name_to_pythonid(name: str) -> str:
 
     name = "_".join(parts)
 
+    if keyword.iskeyword(name):
+        name = name + "_"
+
     return name
 
 
@@ -60,6 +68,8 @@ def is_valid_snake_identifier(name: str) -> bool:
         return False
     if name != name.lower():
         return False  # this is opinionated
+    if not name.isidentifier() or keyword.iskeyword(name):
+        return False
     return True