nodebpy 520.28.0__tar.gz → 520.29.0__tar.gz

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

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

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

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.28.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

{nodebpy-520.28.0 → nodebpy-520.29.0}/src/nodebpy/nodes/compositor/color.py

@@ -84,8 +84,8 @@ class AlphaOver(BaseNode):
 
     def __init__(
         self,
-        background: InputColor = None,
-        foreground: InputColor = None,
+        background: InputColor = (1.0, 1.0, 1.0, 1.0),
+        foreground: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         type: InputMenu | Literal["Over", "Disjoint Over", "Conjoint Over"] = "Over",
         straight_alpha: InputBoolean = False,
@@ -104,8 +104,8 @@ class AlphaOver(BaseNode):
     @classmethod
     def over(
         cls,
-        background: InputColor = None,
-        foreground: InputColor = None,
+        background: InputColor = (1.0, 1.0, 1.0, 1.0),
+        foreground: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         straight_alpha: InputBoolean = False,
     ) -> "AlphaOver":
@@ -121,8 +121,8 @@ class AlphaOver(BaseNode):
     @classmethod
     def disjoint_over(
         cls,
-        background: InputColor = None,
-        foreground: InputColor = None,
+        background: InputColor = (1.0, 1.0, 1.0, 1.0),
+        foreground: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         straight_alpha: InputBoolean = False,
     ) -> "AlphaOver":
@@ -138,8 +138,8 @@ class AlphaOver(BaseNode):
     @classmethod
     def conjoint_over(
         cls,
-        background: InputColor = None,
-        foreground: InputColor = None,
+        background: InputColor = (1.0, 1.0, 1.0, 1.0),
+        foreground: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         straight_alpha: InputBoolean = False,
     ) -> "AlphaOver":
@@ -205,7 +205,7 @@ class BrightnessContrast(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         bright: InputFloat = 0.0,
         contrast: InputFloat = 0.0,
     ):
@@ -363,24 +363,24 @@ class ColorBalance(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         type: InputMenu
         | Literal[
             "Lift/Gamma/Gain", "Offset/Power/Slope (ASC-CDL)", "White Point"
         ] = "Lift/Gamma/Gain",
         base_lift: InputFloat = 0.0,
-        color_lift: InputColor = None,
+        color_lift: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_gamma: InputFloat = 1.0,
-        color_gamma: InputColor = None,
+        color_gamma: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_gain: InputFloat = 1.0,
-        color_gain: InputColor = None,
+        color_gain: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_offset: InputFloat = 0.0,
-        color_offset: InputColor = None,
+        color_offset: InputColor = (0.0, 0.0, 0.0, 1.0),
         base_power: InputFloat = 1.0,
-        color_power: InputColor = None,
+        color_power: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_slope: InputFloat = 1.0,
-        color_slope: InputColor = None,
+        color_slope: InputColor = (1.0, 1.0, 1.0, 1.0),
         input_temperature: InputFloat = 6500.0,
         input_tint: InputFloat = 10.0,
         output_temperature: InputFloat = 6500.0,
@@ -418,14 +418,14 @@ class ColorBalance(BaseNode):
     @classmethod
     def lift_gamma_gain(
         cls,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         base_lift: InputFloat = 0.0,
-        color_lift: InputColor = None,
+        color_lift: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_gamma: InputFloat = 1.0,
-        color_gamma: InputColor = None,
+        color_gamma: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_gain: InputFloat = 1.0,
-        color_gain: InputColor = None,
+        color_gain: InputColor = (1.0, 1.0, 1.0, 1.0),
     ) -> "ColorBalance":
         """Create Color Balance node with type 'Lift/Gamma/Gain'."""
         return cls(
@@ -443,14 +443,14 @@ class ColorBalance(BaseNode):
     @classmethod
     def offset_power_slope_asc_cdl(
         cls,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         base_offset: InputFloat = 0.0,
-        color_offset: InputColor = None,
+        color_offset: InputColor = (0.0, 0.0, 0.0, 1.0),
         base_power: InputFloat = 1.0,
-        color_power: InputColor = None,
+        color_power: InputColor = (1.0, 1.0, 1.0, 1.0),
         base_slope: InputFloat = 1.0,
-        color_slope: InputColor = None,
+        color_slope: InputColor = (1.0, 1.0, 1.0, 1.0),
     ) -> "ColorBalance":
         """Create Color Balance node with type 'Offset/Power/Slope (ASC-CDL)'."""
         return cls(
@@ -468,7 +468,7 @@ class ColorBalance(BaseNode):
     @classmethod
     def white_point(
         cls,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         input_temperature: InputFloat = 6500.0,
         input_tint: InputFloat = 10.0,
@@ -699,7 +699,7 @@ class ColorCorrection(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         mask: InputFloat = 1.0,
         master_saturation: InputFloat = 1.0,
         master_contrast: InputFloat = 1.0,
@@ -835,9 +835,9 @@ class DepthCombine(BaseNode):
 
     def __init__(
         self,
-        a: InputColor = None,
+        a: InputColor = (1.0, 1.0, 1.0, 1.0),
         depth_a: InputFloat = 1.0,
-        b: InputColor = None,
+        b: InputColor = (1.0, 1.0, 1.0, 1.0),
         depth_b: InputFloat = 1.0,
         use_alpha: InputBoolean = False,
         anti_alias: InputBoolean = True,
@@ -901,7 +901,7 @@ class Exposure(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         exposure: InputFloat = 0.0,
     ):
         super().__init__()
@@ -956,7 +956,7 @@ class HueCorrect(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
     ):
         super().__init__()
@@ -1029,7 +1029,7 @@ class HueSaturationValue(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         hue: InputFloat = 0.5,
         saturation: InputFloat = 1.0,
         value: InputFloat = 1.0,
@@ -1105,7 +1105,7 @@ class InvertColor(BaseNode):
 
     def __init__(
         self,
-        color: InputColor = None,
+        color: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
         invert_color: InputBoolean = True,
         invert_alpha: InputBoolean = False,
@@ -1167,7 +1167,7 @@ class Posterize(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         steps: InputFloat = 8.0,
     ):
         super().__init__()
@@ -1234,10 +1234,10 @@ class RGBCurves(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         fac: InputFloat = 1.0,
-        black_level: InputColor = None,
-        white_level: InputColor = None,
+        black_level: InputColor = (0.0, 0.0, 0.0, 1.0),
+        white_level: InputColor = (1.0, 1.0, 1.0, 1.0),
     ):
         super().__init__()
         key_args = {
@@ -1338,7 +1338,7 @@ class Tonemap(BaseNode):
 
     def __init__(
         self,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         type: InputMenu
         | Literal["R/D Photoreceptor", "Rh Simple"] = "R/D Photoreceptor",
         key: InputFloat = 0.18,
@@ -1367,7 +1367,7 @@ class Tonemap(BaseNode):
     @classmethod
     def r_d_photoreceptor(
         cls,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         intensity: InputFloat = 0.0,
         contrast: InputFloat = 0.0,
         light_adaptation: InputFloat = 0.0,
@@ -1386,7 +1386,7 @@ class Tonemap(BaseNode):
     @classmethod
     def rh_simple(
         cls,
-        image: InputColor = None,
+        image: InputColor = (1.0, 1.0, 1.0, 1.0),
         key: InputFloat = 0.18,
         balance: InputFloat = 1.0,
         gamma: InputFloat = 1.0,