nodebpy 520.27.0__tar.gz → 520.29.0__tar.gz

{nodebpy-520.27.0 → nodebpy-520.29.0}/PKG-INFO

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

{nodebpy-520.27.0 → nodebpy-520.29.0}/pyproject.toml

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

{nodebpy-520.27.0 → nodebpy-520.29.0}/src/nodebpy/__init__.py

@@ -1,4 +1,4 @@
-from . import builder, export, nodes, types
+from . import builder, export, live, nodes, types
 from .builder import (
     ArrangeMethod,
     SimpleOptions,
@@ -22,6 +22,7 @@ __all__ = [
     "default_sugiyama_options",
     "export",
     "geometry",
+    "live",
     "nodes",
     "shader",
     "types",

{nodebpy-520.27.0 → nodebpy-520.29.0}/src/nodebpy/builder/tree.py

@@ -1108,11 +1108,28 @@ class TreeBuilder[TreeT: NodeTree]:
         fake_user: bool = False,
         ignore_visibility: bool = False,
         split_inputs: bool | None = None,
+        clear: bool = False,
     ):
+        # ``clear`` rebuilds in place: the tree is emptied (nodes, links and
+        # interface) before the body runs, keeping the datablock so modifiers,
+        # group nodes and pinned editors that reference it stay attached. With
+        # a name, an existing group of that name and tree type is reused
+        # instead of creating a ``Name.001`` duplicate; a group of another
+        # tree type is left alone and a new one is created as usual.
+        # Tree-level properties (description, color_tag, is_tool, fake user,
+        # ...) are kept: only the contents are rebuilt.
         if isinstance(tree, str):
-            self.tree = bpy.data.node_groups.new(tree, tree_type)  # ty: ignore[invalid-assignment]
+            existing = bpy.data.node_groups.get(tree) if clear else None
+            if existing is not None and existing.bl_idname == tree_type:
+                self.tree = existing
+            else:
+                self.tree = bpy.data.node_groups.new(tree, tree_type)  # ty: ignore[invalid-assignment]
         else:
             self.tree = tree  # type: ignore
+        if clear:
+            assert self.tree.interface is not None
+            self.tree.nodes.clear()
+            self.tree.interface.clear()
 
         self._menu_defaults: list[_MenuDefault] = []
         self._exited = False
@@ -1133,6 +1150,7 @@ class TreeBuilder[TreeT: NodeTree]:
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
         split_inputs: bool | None = None,
+        clear: bool = False,
     ) -> TreeBuilder[GeometryNodeTree]:
         """Create a geometry node tree."""
         return cast(
@@ -1144,6 +1162,7 @@ class TreeBuilder[TreeT: NodeTree]:
                 arrange=arrange,
                 fake_user=fake_user,
                 split_inputs=split_inputs,
+                clear=clear,
             ),
         )
 
@@ -1156,6 +1175,7 @@ class TreeBuilder[TreeT: NodeTree]:
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
         split_inputs: bool | None = None,
+        clear: bool = False,
     ) -> TreeBuilder[ShaderNodeTree]:
         """Create a shader node tree."""
         return cast(
@@ -1167,6 +1187,7 @@ class TreeBuilder[TreeT: NodeTree]:
                 arrange=arrange,
                 fake_user=fake_user,
                 split_inputs=split_inputs,
+                clear=clear,
             ),
         )
 
@@ -1179,6 +1200,7 @@ class TreeBuilder[TreeT: NodeTree]:
         arrange: ArrangeMethod = "sugiyama",
         fake_user: bool = False,
         split_inputs: bool | None = None,
+        clear: bool = False,
     ) -> TreeBuilder[CompositorNodeTree]:
         """Create a compositor node tree."""
         return cast(
@@ -1190,6 +1212,7 @@ class TreeBuilder[TreeT: NodeTree]:
                 arrange=arrange,
                 fake_user=fake_user,
                 split_inputs=split_inputs,
+                clear=clear,
             ),
         )
 
@@ -1215,6 +1238,7 @@ class TreeBuilder[TreeT: NodeTree]:
         top_level: Literal["with", "class"] = "with",
         format: bool = True,
         nodebpy_pkg: str = "nodebpy",
+        in_place: bool = False,
     ) -> str:
         """Generate Python source that recreates this tree using nodebpy.
 
@@ -1232,6 +1256,7 @@ class TreeBuilder[TreeT: NodeTree]:
             top_level=top_level,
             format=format,
             nodebpy_pkg=nodebpy_pkg,
+            in_place=in_place,
         )
 
     def to_mermaid(self, fenced: bool = True) -> str:

nodebpy-520.29.0/src/nodebpy/export/_floats.py

@@ -0,0 +1,114 @@
+"""Float formatting shared by ``to_python`` export and the node-class generator.
+
+Blender stores socket values as float32. This module renders such a value as
+the shortest Python literal that rebuilds the identical float32 (``0.1`` rather
+than ``0.10000000149011612``), or as a ``math.pi`` / ``math.tau`` / ``math.e``
+expression for the rational multiples of those constants (``3 * math.pi / 4``).
+
+It is a leaf: stdlib and numpy only, no ``nodebpy`` imports. The generator in
+``gen/`` loads it straight from this file (see ``gen/config.py``) so that a
+broken generated tree can never block regenerating it.
+"""
+
+from __future__ import annotations
+
+import math
+
+import numpy as np
+
+
+def within_one_ulp(candidate: float, f32) -> bool:
+    """Whether ``candidate`` lands on ``f32`` or its immediate float32
+    neighbour. One ULP is the round-off a value picks up crossing precisions
+    (an authored ``0.15`` surviving as ``0.14999999``), so snapping across it
+    restores the authored constant without moving any genuinely different
+    value."""
+    # A candidate beyond float32 range (a huge clamp bound) overflows the
+    # cast to inf with a RuntimeWarning; it is never within one ULP.
+    with np.errstate(over="ignore"):
+        c32 = np.float32(candidate)
+    if not np.isfinite(c32):
+        return False
+    return bool(c32 == f32 or np.nextafter(f32, c32) == c32)
+
+
+def math_constant_expression(f32) -> str | None:
+    """A ``math.pi``/``math.tau``/``math.e`` expression for a rational
+    multiple of one of those constants, or None.
+
+    Constants authored as expressions (``2 * math.pi``, ``pi / 3``, ``tau``,
+    ``e``) survive in a blend only as float32 values; matching small-fraction
+    multiples (within one ULP) restores the readable form. Numerators up to 48
+    over denominators up to 12 cover the usual turns and subdivisions while
+    keeping a chance coincidence with an ordinary decimal essentially
+    impossible. An even multiple of pi renders in tau form (``math.tau``,
+    ``math.tau / 3``) — with the fraction reduced, halving the numerator is
+    always the simpler expression.
+    """
+    magnitude = abs(float(f32))
+    if magnitude == 0.0:
+        return None
+    for name, const in (("pi", math.pi), ("e", math.e)):
+        for den in range(1, 13):
+            num = round(magnitude * den / const)
+            if not 1 <= num <= 48 or math.gcd(num, den) != 1:
+                continue
+            if not within_one_ulp(num * const / den, abs(f32)):
+                continue
+            if name == "pi" and num % 2 == 0:
+                name, num = "tau", num // 2
+            expr = f"math.{name}" if num == 1 else f"{num} * math.{name}"
+            if den > 1:
+                expr = f"{expr} / {den}"
+            return f"-{expr}" if float(f32) < 0 else expr
+    return None
+
+
+def group_digits(text: str) -> str:
+    """Underscore-group a positional float literal's integer part when it has
+    five or more digits (``10000.0`` → ``10_000.0``)."""
+    sign = ""
+    if text.startswith("-"):
+        sign, text = "-", text[1:]
+    int_part, dot, frac = text.partition(".")
+    if len(int_part) < 5:
+        return sign + text
+    return sign + f"{int(int_part):_}" + dot + frac
+
+
+def fmt_float(value: float, *, snap: bool = True) -> str:
+    """Shortest readable literal for a float32-backed value.
+
+    Blender stores socket values as float32, so reading them back through
+    Python gives noisy float64 reprs (``0.10000000149011612``); the shortest
+    decimal that uniquely identifies the float32 (``0.1``) rebuilds the
+    identical socket value. On top of that, rational multiples of pi, tau
+    and e render as ``math.*`` expressions, a value one ULP off a much shorter decimal
+    snaps to it (``0.14999999`` → ``0.15``), and long integer parts get
+    underscore grouping (``-10_000.0``). ``snap=False`` keeps the literal that
+    rebuilds exactly this float32 (a generated default must be Blender's own
+    value, not its prettier neighbour).
+    """
+    if not math.isfinite(value):
+        return repr(value)
+    f32 = np.float32(value)
+    if float(f32) != value:
+        return repr(value)  # genuine float64 — keep full precision
+    const_expr = math_constant_expression(f32)
+    if const_expr is not None:
+        return const_expr
+    text = np.format_float_positional(f32, unique=True, trim="0")
+    # Snap to the shortest decimal within one ULP: fewer significant digits
+    # first, so ``0.14999999`` becomes ``0.15`` rather than ``0.1499999``.
+    digits = sum(c.isdigit() for c in text.lstrip("-0.")) if snap else 0
+    for sig in range(1, digits):
+        candidate = float(f"%.{sig}g" % float(f32))
+        if not within_one_ulp(candidate, f32):
+            continue
+        snapped = np.format_float_positional(
+            np.float32(candidate), unique=True, trim="0"
+        )
+        if len(snapped) < len(text):
+            text = snapped
+        break
+    return group_digits(text)

{nodebpy-520.27.0 → nodebpy-520.29.0}/src/nodebpy/export/codegen.py

@@ -31,8 +31,13 @@ from collections.abc import Callable, Collection, Mapping
 from dataclasses import dataclass, field
 from typing import TYPE_CHECKING, Any, Literal, NamedTuple
 
+import numpy as np
 from bpy.types import ID, FunctionNodeCompare, NodeTree
 
+from ._floats import (
+    fmt_float as _fmt_float,
+)
+
 if TYPE_CHECKING:
     from ..builder.tree import TreeBuilder
 
@@ -354,111 +359,6 @@ def _stmt_lines(
 # ---------------------------------------------------------------------------
 
 
-def _within_one_ulp(candidate: float, f32) -> bool:
-    """Whether ``candidate`` lands on ``f32`` or its immediate float32
-    neighbour. One ULP is the round-off a value picks up crossing precisions
-    (an authored ``0.15`` surviving as ``0.14999999``), so snapping across it
-    restores the authored constant without moving any genuinely different
-    value."""
-    import numpy as np
-
-    # A candidate beyond float32 range (a huge clamp bound) overflows the
-    # cast to inf with a RuntimeWarning; it is never within one ULP.
-    with np.errstate(over="ignore"):
-        c32 = np.float32(candidate)
-    if not np.isfinite(c32):
-        return False
-    return bool(c32 == f32 or np.nextafter(f32, c32) == c32)
-
-
-def _math_constant_expression(f32) -> str | None:
-    """A ``math.pi``/``math.tau``/``math.e`` expression for a rational
-    multiple of one of those constants, or None.
-
-    Constants authored as expressions (``2 * math.pi``, ``pi / 3``, ``tau``,
-    ``e``) survive in a blend only as float32 values; matching small-fraction
-    multiples (within one ULP) restores the readable form. Numerators up to 48
-    over denominators up to 12 cover the usual turns and subdivisions while
-    keeping a chance coincidence with an ordinary decimal essentially
-    impossible. An even multiple of pi renders in tau form (``math.tau``,
-    ``math.tau / 3``) — with the fraction reduced, halving the numerator is
-    always the simpler expression.
-    """
-    import math
-
-    magnitude = abs(float(f32))
-    if magnitude == 0.0:
-        return None
-    for name, const in (("pi", math.pi), ("e", math.e)):
-        for den in range(1, 13):
-            num = round(magnitude * den / const)
-            if not 1 <= num <= 48 or math.gcd(num, den) != 1:
-                continue
-            if not _within_one_ulp(num * const / den, abs(f32)):
-                continue
-            if name == "pi" and num % 2 == 0:
-                name, num = "tau", num // 2
-            expr = f"math.{name}" if num == 1 else f"{num} * math.{name}"
-            if den > 1:
-                expr = f"{expr} / {den}"
-            return f"-{expr}" if float(f32) < 0 else expr
-    return None
-
-
-def _group_digits(text: str) -> str:
-    """Underscore-group a positional float literal's integer part when it has
-    five or more digits (``10000.0`` → ``10_000.0``)."""
-    sign = ""
-    if text.startswith("-"):
-        sign, text = "-", text[1:]
-    int_part, dot, frac = text.partition(".")
-    if len(int_part) < 5:
-        return sign + text
-    return sign + f"{int(int_part):_}" + dot + frac
-
-
-def _fmt_float(value: float) -> str:
-    """Shortest readable literal for a float32-backed value.
-
-    Blender stores socket values as float32, so reading them back through
-    Python gives noisy float64 reprs (``0.10000000149011612``); the shortest
-    decimal that uniquely identifies the float32 (``0.1``) rebuilds the
-    identical socket value. On top of that, rational multiples of pi, tau
-    and e render as ``math.*`` expressions, a value one ULP off a much shorter decimal
-    snaps to it (``0.14999999`` → ``0.15``), and long integer parts get
-    underscore grouping (``-10_000.0``).
-    """
-    import math
-
-    if not math.isfinite(value):
-        return repr(value)
-    try:
-        import numpy as np
-    except ImportError:  # pragma: no cover - Blender ships numpy
-        return repr(value)
-    f32 = np.float32(value)
-    if float(f32) != value:
-        return repr(value)  # genuine float64 — keep full precision
-    const_expr = _math_constant_expression(f32)
-    if const_expr is not None:
-        return const_expr
-    text = np.format_float_positional(f32, unique=True, trim="0")
-    # Snap to the shortest decimal within one ULP: fewer significant digits
-    # first, so ``0.14999999`` becomes ``0.15`` rather than ``0.1499999``.
-    digits = sum(c.isdigit() for c in text.lstrip("-0."))
-    for sig in range(1, digits):
-        candidate = float(f"%.{sig}g" % float(f32))
-        if not _within_one_ulp(candidate, f32):
-            continue
-        snapped = np.format_float_positional(
-            np.float32(candidate), unique=True, trim="0"
-        )
-        if len(snapped) < len(text):
-            text = snapped
-        break
-    return _group_digits(text)
-
-
 def _fmt(value: Any) -> str:
     """Format a value as a Python literal using double-quoted strings."""
     if isinstance(value, bool):
@@ -507,7 +407,9 @@ def _eq(a: Any, b: Any) -> bool:
                 return False
             return all(_eq(x, y) for x, y in zip(a, b))
         if isinstance(a, (int, float)) and isinstance(b, (int, float)):
-            return float(a) == float(b)
+            # Sockets store float32: a Python default of ``0.05`` reads back
+            # as ``0.05000000074505806``, so compare at that precision.
+            return bool(np.float32(a) == np.float32(b))
         return a == b
     except Exception:  # noqa: BLE001
         return False
@@ -3724,6 +3626,7 @@ def to_python(
     external_groups: Collection[str] | None = None,
     typed_groups: Collection[str] | None = None,
     root_interface: GroupInterface | None = None,
+    in_place: bool = False,
 ) -> str:
     """Generate Python code that recreates the given node tree using nodebpy.
 
@@ -3794,6 +3697,17 @@ def to_python(
         Typed-interface parts (docstring, class attributes, accessors and
         ``__init__``) spliced into the top-level tree's class in ``class``
         mode, ahead of ``_build_group``.
+    in_place: bool
+        If True, the ``with`` header is emitted as
+        ``with g.tree("Name", clear=True) as tree:`` so running the source
+        rebuilds the exported tree in place — the same datablock, emptied
+        first — instead of creating a ``Name.001`` copy, keeping modifiers,
+        group nodes and pinned editors attached across re-runs. Only the
+        top-level tree is rebuilt this way: nested groups are emitted as
+        ``Custom*Group`` classes whose ``create_group()`` reuses an existing
+        tree of the same name, so edits to them only take effect through
+        :func:`nodebpy.live.run_source`. Ignored with ``top_level="class"``
+        (a class is rebuilt by ``run_source``, not by a header).
 
     Returns
     -------
@@ -3876,6 +3790,8 @@ def to_python(
         # for either option.
         if snapshot_positions or keep_reroutes:
             ctor_args.append("arrange=None")
+        if in_place:
+            ctor_args.append("clear=True")
         lines.append(f"with {constructor}({', '.join(ctor_args)}) as tree:")
         lines.extend(_assemble_tree_body(emission))