nodebpy 520.16.0__tar.gz → 520.18.0__tar.gz

{nodebpy-520.16.0 → nodebpy-520.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.16.0
+Version: 520.18.0
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>

{nodebpy-520.16.0 → nodebpy-520.18.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.16.0"
+version = "520.18.0"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [

{nodebpy-520.16.0 → nodebpy-520.18.0}/src/nodebpy/assets/__init__.py

@@ -6,15 +6,23 @@ classes for the node groups in a ``.blend`` asset library into a single module;
 (``geometry.py`` / ``shader.py`` / ``compositor.py``). The bundled-essentials
 APIs generated for nodebpy itself live in ``nodebpy.nodes.{geometry,shader,
 compositor}.assets`` and are re-exported alongside the built-in nodes.
+
+``dump_library`` and ``build_library`` round-trip a ``.blend`` asset library
+through Python source: every asset is dumped to its own ``.py`` file (the
+version-controlled source of truth) and the ``.blend`` is rebuilt from them
+(``python -m nodebpy.assets dump/build``).
 """
 
 from ..builder import AssetLibrary, BundledLibrary, PackageLibrary
 from ._codegen import generate_asset_api, generate_asset_modules
+from ._library import build_library, dump_library
 
 __all__ = [
     "AssetLibrary",
     "BundledLibrary",
     "PackageLibrary",
+    "build_library",
+    "dump_library",
     "generate_asset_api",
     "generate_asset_modules",
 ]

{nodebpy-520.16.0 → nodebpy-520.18.0}/src/nodebpy/assets/__main__.py

@@ -5,12 +5,17 @@ libraries and writes typed classes to ``nodebpy/nodes/{geometry,shader,
 compositor}/assets.py``, where ``python -m gen`` re-exports them so they are
 available alongside the built-in nodes (e.g. ``g.SmoothByAngle()``). Run *before*
 ``python -m gen`` and through the ruff/ty post-processing (see the Makefile).
+
+``python -m nodebpy.assets dump <blend> <dir>`` and ``… build <dir> <blend>``
+instead round-trip a ``.blend`` asset library through per-asset Python sources
+(see :mod:`nodebpy.assets._library`).
 """
 
 from __future__ import annotations
 
 import argparse
 import os
+import sys
 from pathlib import Path
 
 from ..builder import BundledLibrary, PackageLibrary
@@ -57,8 +62,27 @@ def generate_essentials(
     return written
 
 
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser()
+def parse_args() -> argparse.Namespace:  # pragma: no cover - CLI wrapper
+    parser = argparse.ArgumentParser(
+        prog="python -m nodebpy.assets",
+        description=(
+            "Generate typed nodebpy API classes for node-group assets. "
+            "Without a subcommand this regenerates the bundled-essentials "
+            "asset APIs (or, with --blend-file, generates an API module for "
+            "a custom asset library)."
+        ),
+        epilog=(
+            "subcommands:\n"
+            "  dump <blend> <output-dir>    dump every node-group asset in a "
+            ".blend to per-asset .py source files\n"
+            "  build <source-dir> <blend>   rebuild the .blend asset library "
+            "from dumped .py source files\n"
+            "\n"
+            "See 'python -m nodebpy.assets dump --help' and "
+            "'python -m nodebpy.assets build --help' for their options."
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
     parser.add_argument(
         "--blend-file",
         "-b",
@@ -100,6 +124,14 @@ def parse_args() -> argparse.Namespace:
 
 
 def main() -> None:  # pragma: no cover - CLI wrapper
+    # The dump/build subcommands (blend ↔ .py round-trip) have their own
+    # parser; everything else keeps the original flag-based interface.
+    if len(sys.argv) > 1 and sys.argv[1] in ("dump", "build"):
+        from ._library import main as library_main
+
+        library_main(sys.argv[1:])
+        return
+
     args = parse_args()
     output = (
         args.output

{nodebpy-520.16.0 → nodebpy-520.18.0}/src/nodebpy/assets/_codegen.py

@@ -22,7 +22,8 @@ from typing import cast
 import bpy
 
 from ..builder import AssetLibrary, BundledLibrary, asset_group_base
-from ..builder._utils import normalize_name
+from ..builder._utils import normalize_name, typed_param_names
+from ..export.codegen import GroupInterface, _fmt
 
 # bl_socket_type substring → (Socket accessor class, Input* parameter type).
 # Order matters: more specific keys (IntVector before Int) come first.
@@ -90,7 +91,10 @@ def _format_default(socket: bpy.types.NodeSocket) -> str:
     if isinstance(value, int):
         return str(value)
     if isinstance(value, float):
-        return str(round(value, 6))
+        # The exact float32 round-trip formatter (which also folds pi/tau/e
+        # constants): a lossy default here would *change* the socket value on
+        # every instantiation, since the typed __init__ always passes it.
+        return _fmt(value)
     if isinstance(value, str):
         return repr(value)
     return "None"
@@ -286,7 +290,7 @@ def _introspect(library: AssetLibrary, names: set[str] | None) -> list[_AssetCla
 def _library_source(library: AssetLibrary) -> str:
     """Source expression that reconstructs ``library`` in the generated module."""
     if isinstance(library, BundledLibrary):
-        return f"BundledLibrary({library.filename!r})"
+        return f"BundledLibrary({_fmt(library.filename)})"
     from ..builder import PackageLibrary
 
     if isinstance(library, PackageLibrary):
@@ -294,7 +298,7 @@ def _library_source(library: AssetLibrary) -> str:
         # so the generated module imports cleanly and stays cross-platform even
         # when ``relative`` was passed as a ``Path``.
         relative = Path(library.relative).as_posix()
-        return f"PackageLibrary(__file__, {relative!r})"
+        return f"PackageLibrary(__file__, {_fmt(relative)})"
     raise TypeError(f"Cannot serialise asset library: {library!r}")
 
 
@@ -351,8 +355,8 @@ def _render_class(cls: _AssetClass, docstrings: bool = False) -> str:
     return f"""class {cls.class_name}({base}):
     {docstring}
 
-    _name = {cls.asset_name!r}
-    _asset_name = {cls.asset_name!r}
+    _name = {_fmt(cls.asset_name)}
+    _asset_name = {_fmt(cls.asset_name)}
     _library = {cls.library_source}
 
 {inputs_cls}
@@ -370,6 +374,112 @@ def _render_class(cls: _AssetClass, docstrings: bool = False) -> str:
 """
 
 
+def interface_parts(
+    group,
+    *,
+    library_source: str | None,
+    nodebpy_pkg: str = "nodebpy",
+) -> tuple[GroupInterface, list[str]]:
+    """The typed-interface parts of a merged dump class for ``group`` (a live
+    ``bpy.types.NodeTree``), plus the import lines they require.
+
+    The parts — numpydoc docstring, ``_asset_name``/``_library`` attributes,
+    ``_Inputs``/``_Outputs`` accessors and the typed ``__init__`` — are spliced
+    by :func:`nodebpy.export.to_python` into the class it emits around
+    ``_build_group``, so one class both documents the group and carries the
+    recipe that regenerates it.
+
+    With ``library_source`` (a ``PackageLibrary(...)`` expression), the class
+    becomes an appending ``Asset*Group``; without it (shared helper groups,
+    which are not assets), only the typed API is added and the ``Custom*Group``
+    base stays.
+
+    The ``__init__`` keys its super call by socket *name* (with a
+    ``_named_links`` fallback for duplicate names) rather than by identifier:
+    identifiers are authoring-history artifacts that a tree rebuilt from
+    ``_build_group`` reassigns, while names round-trip. Parameter names come
+    from :func:`~nodebpy.builder._utils.typed_param_names` — the same mapping
+    codegen uses for call sites, so generated calls match the signature.
+    """
+    cls = _introspect_group(group, group.name, library_source or "")
+    # Align accessor/parameter names with the shared call-site mapping.
+    for side in (cls.inputs, cls.outputs):
+        params = typed_param_names(side)
+        for s in side:
+            s.attr = params[s.identifier]
+
+    docstring = f"    {_class_docstring(cls)}"
+
+    params = [f"{s.attr}: {s.param_type} = {s.default}" for s in cls.inputs]
+    signature = (
+        "(\n        self,\n        " + ",\n        ".join(params) + ",\n    )"
+        if params
+        else "(self)"
+    )
+    name_counts = Counter(s.name for s in cls.inputs)
+    keyed = [
+        f"{_quote(s.name)}: {s.attr}" for s in cls.inputs if name_counts[s.name] == 1
+    ]
+    pairs = [
+        f"({_quote(s.name)}, {s.attr})" for s in cls.inputs if name_counts[s.name] > 1
+    ]
+    args = []
+    if keyed:
+        args.append("**{" + ", ".join(keyed) + "}")
+    if pairs:
+        args.append("_named_links=[" + ", ".join(pairs) + "]")
+    init = f"    def __init__{signature}:\n        super().__init__({', '.join(args)})"
+
+    type_checking = (
+        "    if TYPE_CHECKING:\n"
+        "        @property\n"
+        "        def i(self) -> _Inputs: ...\n"
+        "        @property\n"
+        "        def o(self) -> _Outputs: ..."
+    )
+    body = "\n\n".join(
+        [
+            _accessor(cls.inputs, "_Inputs", docstrings=True),
+            _accessor(cls.outputs, "_Outputs", docstrings=True),
+            type_checking,
+            init,
+        ]
+    )
+
+    base: str | None = None
+    attr_lines: list[str] = []
+    if library_source:
+        base = asset_group_base(cls.tree_idname).__name__
+        attr_lines = [
+            f"_asset_name = {_fmt(cls.asset_name)}",
+            f"_library = {library_source}",
+        ]
+
+    socket_classes = sorted({s.socket_class for s in cls.inputs + cls.outputs})
+    input_types = sorted({s.input_type for s in cls.inputs})
+    typing_names = ["TYPE_CHECKING"]
+    if any(s.menu_items for s in cls.inputs):
+        typing_names.append("Literal")
+    builder_names = {"SocketAccessor", *socket_classes}
+    if library_source:
+        builder_names.add(library_source.partition("(")[0])
+    import_lines = [
+        f"from typing import {', '.join(typing_names)}",
+        f"from {nodebpy_pkg}.builder import {', '.join(sorted(builder_names))}",
+    ]
+    if any("math." in s.default for s in cls.inputs):
+        import_lines.insert(0, "import math")
+    if input_types:
+        import_lines.append(f"from {nodebpy_pkg}.types import {', '.join(input_types)}")
+
+    return (
+        GroupInterface(
+            docstring=docstring, body=body, base=base, attr_lines=attr_lines
+        ),
+        import_lines,
+    )
+
+
 def _render_module(
     classes: list[_AssetClass],
     nodebpy_pkg: str = "nodebpy",
@@ -399,6 +509,9 @@ def _render_module(
 
     lines = [
         "# Auto-generated by nodebpy.assets.generate_asset_api — do not edit manually.",
+        "import math"
+        if any("math." in s.default for c in classes for s in c.inputs)
+        else "",
         f"from typing import {', '.join(typing_imports)}",
         "",
         f"from {nodebpy_pkg}.builder import (\n    {',\n    '.join(builder_imports)},\n)",