nodebpy 520.17.0__tar.gz → 520.18.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.17.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.17.0 → nodebpy-520.18.0}/pyproject.toml

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

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

@@ -290,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):
@@ -298,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}")
 
 
@@ -355,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}
@@ -451,7 +451,7 @@ def interface_parts(
     if library_source:
         base = asset_group_base(cls.tree_idname).__name__
         attr_lines = [
-            f"_asset_name = {cls.asset_name!r}",
+            f"_asset_name = {_fmt(cls.asset_name)}",
             f"_library = {library_source}",
         ]
 

{nodebpy-520.17.0 → nodebpy-520.18.0}/src/nodebpy/assets/_library.py

@@ -74,6 +74,7 @@ from ..export.codegen import (
     _ID_COLLECTIONS,
     GroupInterface,
     _class_name,
+    _fmt,
     _format_with_ruff,
     to_python,
 )
@@ -215,7 +216,7 @@ def _id_defaults(tree) -> dict[str, set[str]]:
 
 def _dict_lines(name: str, data: dict[str, object]) -> list[str]:
     lines = [f"{name} = {{"]
-    lines += [f"    {key!r}: {value!r}," for key, value in data.items()]
+    lines += [f"    {_fmt(key)}: {_fmt(value)}," for key, value in data.items()]
     lines.append("}")
     return lines
 
@@ -336,9 +337,9 @@ def _render_group_module(
     # Deliberately no source filename/timestamp in the header: a dump must be
     # byte-identical across a no-op round-trip so it leaves no VCS diff.
     label = {
-        "asset": f"Node-group asset {group.name!r} ({group.bl_idname})",
-        "shared": f"Node group {group.name!r} ({group.bl_idname})",
-        "material": f"Material {material_name!r}",
+        "asset": f'Node-group asset "{group.name}" ({group.bl_idname})',
+        "shared": f'Node group "{group.name}" ({group.bl_idname})',
+        "material": f'Material "{material_name}"',
     }[kind]
     header = [
         f"# {label}, dumped by nodebpy.assets.dump_library.",
@@ -375,7 +376,7 @@ def _render_group_module(
             "",
             "",
             f"MATERIAL = {class_name}",
-            f"MATERIAL_NAME = {material_name!r}",
+            f"MATERIAL_NAME = {_fmt(material_name)}",
         ]
         material = bpy.data.materials[material_name]
         props = _material_properties(material)
@@ -773,7 +774,7 @@ def _dump_appended(
             if kind == "asset":
                 module_dir = (output_dir / module).parent
                 relpath = Path(os.path.relpath(library_blend, module_dir)).as_posix()
-                library_source = f"PackageLibrary(__file__, {relpath!r})"
+                library_source = f"PackageLibrary(__file__, {_fmt(relpath)})"
             root_interface, iface_imports = interface_parts(
                 group, library_source=library_source, nodebpy_pkg=nodebpy_pkg
             )

{nodebpy-520.17.0 → nodebpy-520.18.0}/src/nodebpy/builder/node.py

@@ -455,7 +455,7 @@ class NodeGroupBuilder[T: bpy.types.NodeTree](BaseNode, ABC):
         ...
 
     @abstractmethod
-    def _build_group(self, tree: TreeBuilder) -> None:
+    def _build_group(self, tree: TreeBuilder[T]) -> None:
         """Build the node group internals and interface."""
 
     @classmethod

{nodebpy-520.17.0 → nodebpy-520.18.0}/src/nodebpy/export/codegen.py

@@ -485,9 +485,12 @@ def _fmt(value: Any) -> str:
     # Vectors / sequences
     try:
         items = list(value)
-        return f"({', '.join(_fmt(v) for v in items)})"
     except TypeError:
         return repr(value)
+    if len(items) == 1:
+        # The trailing comma keeps a one-element tuple a tuple.
+        return f"({_fmt(items[0])},)"
+    return f"({', '.join(_fmt(v) for v in items)})"
 
 
 def _eq(a: Any, b: Any) -> bool:
@@ -3652,8 +3655,10 @@ def _emit_interface_lines(node_tree, ctx: EmitContext) -> list[str]:
 
 
 def _format_with_ruff(code: str) -> str:
-    """Format ``code`` with ruff if the optional ``ruff`` package is installed,
-    otherwise return it unchanged.
+    """Run ``code`` through ``ruff check --fix-only`` and ``ruff format`` if
+    the optional ``ruff`` package is installed, otherwise return it unchanged
+    — so generated files come out already fixed and formatted rather than
+    needing a lint pass afterwards.
 
     Uses the binary bundled with the ``ruff`` Python package (via
     ``ruff.find_ruff_bin``), so it works wherever the package is importable —
@@ -3665,20 +3670,24 @@ def _format_with_ruff(code: str) -> str:
         return code
     import subprocess
 
-    try:
-        result = subprocess.run(
-            [find_ruff_bin(), "format", "-"],
-            input=code,
-            capture_output=True,
-            # Explicit UTF-8: text mode alone uses the locale encoding, and on
-            # Windows (cp1252) any non-ASCII character in the source reaches
-            # ruff as invalid UTF-8 — it errors and the code stays unformatted.
-            encoding="utf-8",
-            check=True,
-        )
-    except (OSError, subprocess.SubprocessError):
-        return code
-    return result.stdout or code
+    ruff = find_ruff_bin()
+    for command in (["check", "--fix-only", "-"], ["format", "-"]):
+        try:
+            result = subprocess.run(
+                [ruff, *command],
+                input=code,
+                capture_output=True,
+                # Explicit UTF-8: text mode alone uses the locale encoding,
+                # and on Windows (cp1252) any non-ASCII character in the
+                # source reaches ruff as invalid UTF-8 — it errors and the
+                # code stays unformatted.
+                encoding="utf-8",
+                check=True,
+            )
+        except (OSError, subprocess.SubprocessError):  # pragma: no cover
+            return code
+        code = result.stdout or code
+    return code
 
 
 def to_python(
@@ -3811,10 +3820,17 @@ def to_python(
         for alias in ("g", "s", "c")
         if alias in used_aliases
     ]
-    # TreeBuilder is only referenced by the `with` block; class bodies use the
-    # ``tree`` parameter of ``_build_group`` instead.
-    import_names = import_parts + (["TreeBuilder"] if top_level == "with" else [])
+    # TreeBuilder anchors the `with` block and annotates every generated
+    # ``_build_group(self, tree: TreeBuilder)``, so editors type the whole
+    # body of a dumped class.
+    import_names = import_parts + ["TreeBuilder"]
     lines: list[str] = []
+    if collector.tree_param_types:
+        # The ``tree: TreeBuilder[GeometryNodeTree]`` annotations on emitted
+        # classes reference the bpy tree types by name.
+        lines.append(
+            "from bpy.types import " + ", ".join(sorted(collector.tree_param_types))
+        )
     if import_names:
         lines.append(f"from {nodebpy_pkg} import " + ", ".join(import_names))
     if collector.bases_used:
@@ -3850,9 +3866,9 @@ def to_python(
             lines.append("")
             lines.extend(_node_positions_lines(node_tree, indent=""))
 
-    # Datablock defaults (a Material/Object/Image socket value) render via
-    # ``repr()`` as ``bpy.data.<collection>['name']``, so the module needs a
-    # bare ``import bpy`` to resolve them on rebuild.
+    # Datablock defaults (a Material/Object/Image socket value) render as
+    # guarded ``bpy.data.<collection>.get("name")`` lookups, so the module
+    # needs a bare ``import bpy`` to resolve them on rebuild.
     # Math-constant expressions (from _fmt_float) need the stdlib import.
     if any(re.search(r"\bmath\.(pi|tau|e)\b", line) for line in lines):
         lines.insert(0, "import math")
@@ -4035,6 +4051,8 @@ class _GroupCollector:
     used_names: set[str] = field(default_factory=set)
     bases_used: set[str] = field(default_factory=set)
     used_aliases: set[str] = field(default_factory=set)
+    # bpy.types names the emitted ``tree: TreeBuilder[...]`` annotations need.
+    tree_param_types: set[str] = field(default_factory=set)
 
     def register(self, node_tree) -> str:
         """Ensure a class exists for ``node_tree`` and return its name."""
@@ -4057,6 +4075,10 @@ class _GroupCollector:
         if interface is not None and interface.base:
             base = interface.base
         self.bases_used.add(base)
+        if node_tree.bl_idname in _GROUP_BASE_FOR_TREE:
+            # A tree's bl_idname doubles as its bpy.types class name, which
+            # parameterizes the emitted ``tree: TreeBuilder[...]`` annotation.
+            self.tree_param_types.add(node_tree.bl_idname)
         self.class_defs.append(
             _render_group_class(
                 class_name,
@@ -4312,7 +4334,13 @@ def _render_group_class(
         header.append(f"    _tree_properties = {{{rendered}}}")
     if interface is not None:
         header.extend(["", interface.body])
-    header.extend(["", "    def _build_group(self, tree):"])
+    # The tree's bl_idname doubles as its bpy.types class name.
+    annotation = (
+        f"TreeBuilder[{node_tree.bl_idname}]"
+        if node_tree.bl_idname in _GROUP_BASE_FOR_TREE
+        else "TreeBuilder"
+    )
+    header.extend(["", f"    def _build_group(self, tree: {annotation}) -> None:"])
     inner = _assemble_tree_body(emission)
     # Either option needs auto-layout off (it dissolves reroutes and overwrites
     # locations); the disable line goes at the body's "in-block" 4-space indent,