nodebpy 520.34.1__tar.gz → 520.35.1__tar.gz

{nodebpy-520.34.1 → nodebpy-520.35.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 520.34.1
+Version: 520.35.1
 Summary: Build nodes trees in Blender more elegantly with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
@@ -20,6 +20,7 @@ Description-Content-Type: text/markdown
 [![Run
 Tests](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml/badge.svg)](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml)
 [![](https://codecov.io/gh/BradyAJohnston/nodebpy/graph/badge.svg?token=buThDQZUED)](https://codecov.io/gh/BradyAJohnston/nodebpy)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://app.codspeed.io/BradyAJohnston/nodebpy?utm_source=badge)
 
 Build node trees in Blender more elegantly with Python code. Geometry Nodes, Shader Nodes and Compositor nodes are all fully supported, with type hints and IDE auto-completion throughout.
 

{nodebpy-520.34.1 → nodebpy-520.35.1}/README.md

@@ -3,6 +3,7 @@
 [![Run
 Tests](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml/badge.svg)](https://github.com/BradyAJohnston/nodebpy/actions/workflows/tests.yml)
 [![](https://codecov.io/gh/BradyAJohnston/nodebpy/graph/badge.svg?token=buThDQZUED)](https://codecov.io/gh/BradyAJohnston/nodebpy)
+[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://app.codspeed.io/BradyAJohnston/nodebpy?utm_source=badge)
 
 Build node trees in Blender more elegantly with Python code. Geometry Nodes, Shader Nodes and Compositor nodes are all fully supported, with type hints and IDE auto-completion throughout.
 

{nodebpy-520.34.1 → nodebpy-520.35.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "520.34.1"
+version = "520.35.1"
 description = "Build nodes trees in Blender more elegantly with code"
 readme = "README.md"
 authors = [
@@ -49,6 +49,7 @@ dev = [
     "ty==0.0.74",
     "matplotlib>=3.11.2",
     "databpy>=0.9.0",
+    "pytest-codspeed>=5.0.3",
 ]
 
 # The bpy stubs mark most collections/pointers as `| None` and cannot type

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/builder/__init__.py

@@ -16,6 +16,7 @@ from .asset import (
     PackageLibrary,
     asset_group_base,
     build_from_source,
+    link_assets,
 )
 from .items import Item, ItemsMixin, MenuItem
 from .mixins import LinkingMixin, OperatorMixin
@@ -162,5 +163,6 @@ __all__ = [
     "default_split_inputs",
     "default_sugiyama_options",
     "denormalize_name",
+    "link_assets",
     "normalize_name",
 ]

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/builder/asset.py

@@ -127,22 +127,67 @@ class _AssetGroupMixin:
         cls = type(self)
         if _build_from_source_depth and cls._has_build_source():
             return super()._create_group()  # ty: ignore[unresolved-attribute]
+        group = link_assets(cls).get(cls)
+        if group is None:  # no library on disk, build from the recipe instead
+            return super()._create_group()  # ty: ignore[unresolved-attribute]
+        return group
+
+
+def link_assets(*groups: type[_AssetGroupMixin]) -> dict[type, Any]:
+    """Link several asset groups, reading each asset library once.
+
+    Creating an asset group reads its whole ``.blend`` library, which costs the
+    same however few groups are taken from it. Linking the groups a tree is about
+    to use up front, in one read per library, avoids paying that for each one;
+    the groups' nodes then reuse the linked trees.
+
+    Groups already in the file (same name and tree type) are reused, and groups
+    that would build from their ``_build_group`` source (inside
+    :func:`build_from_source`, or with no library on disk) are skipped.
+
+    Returns
+    -------
+    dict
+        The node tree for each linked or reused group class.
+
+    Raises
+    ------
+    FileNotFoundError
+        A group without a build recipe has no library on disk.
+    KeyError
+        A library does not contain the requested group.
+    """
+    trees: dict[type, Any] = {}
+    to_link: dict[str, list[type[_AssetGroupMixin]]] = {}
+    for cls in groups:
+        if _build_from_source_depth and cls._has_build_source():
+            continue
         existing = bpy.data.node_groups.get(cls._asset_name)
         if existing is not None and existing.bl_idname == cls._tree_idname:
-            return existing
+            trees[cls] = existing
+            continue
         path = cls._library.path()
         if not os.path.exists(path):
             if cls._has_build_source():
-                return super()._create_group()  # ty: ignore[unresolved-attribute]
+                continue
             raise FileNotFoundError(f"Asset library not found: {path}")
+        to_link.setdefault(path, []).append(cls)
+
+    for path, classes in to_link.items():
+        names = list(dict.fromkeys(cls._asset_name for cls in classes))
         with bpy.data.libraries.load(path, link=True, pack=True, assets_only=True) as (  # ty: ignore[invalid-context-manager]
             src,
             dst,
         ):
-            if cls._asset_name not in src.node_groups:
-                raise KeyError(f"Node group {cls._asset_name!r} not found in {path}")
-            dst.node_groups = [cls._asset_name]
-        return dst.node_groups[0]
+            for name in names:
+                if name not in src.node_groups:
+                    raise KeyError(f"Node group {name!r} not found in {path}")
+            # a copy: Blender swaps the names in this list for the linked trees
+            dst.node_groups = list(names)
+        linked = dict(zip(names, dst.node_groups))
+        for cls in classes:
+            trees[cls] = linked[cls._asset_name]
+    return trees
 
 
 class AssetGeometryGroup(_AssetGroupMixin, CustomGeometryGroup):
@@ -179,6 +224,7 @@ __all__ = [
     "PackageLibrary",
     "asset_group_base",
     "build_from_source",
+    "link_assets",
 ]
 
 # Public alias for the mixin, for type hints / isinstance in generated code.

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/export/codegen.py

@@ -1555,11 +1555,65 @@ def _non_default_props(node, cls: type) -> dict[str, Any]:
             current = getattr(node, rna_name)
         except AttributeError:
             continue
+        if rna_name == "is_active_output":
+            if current and _has_sibling_output(node):
+                result[name] = True
+            continue
+        if rna_name in _DERIVED_PROPS:
+            continue
+        if param.default is None:
+            # left to Blender unless passed, so compare with what Blender sets
+            # on a new node in this kind of tree (Noise Texture is 2D in the
+            # compositor and 3D elsewhere)
+            fresh = _fresh_property(node, rna_name)
+            if fresh is not _UNKNOWN and current == fresh:
+                continue
+            result[name] = current
+            continue
         if current != param.default:
             result[name] = current
     return result
 
 
+_UNKNOWN = object()
+_FRESH_PROPERTIES: dict[tuple[str, str, str], object] = {}
+
+
+def _fresh_property(node, rna_name: str) -> object:
+    """``rna_name`` on a freshly added node of this type in this kind of tree."""
+    tree_idname = getattr(getattr(node, "id_data", None), "bl_idname", "")
+    key = (tree_idname, node.bl_idname, rna_name)
+    if key not in _FRESH_PROPERTIES:
+
+        def probe(probe_tree) -> object:
+            return getattr(probe_tree.nodes.new(node.bl_idname), rna_name)
+
+        _FRESH_PROPERTIES[key] = _with_probe_tree(tree_idname, probe, _UNKNOWN)
+    return _FRESH_PROPERTIES[key]
+
+
+# Properties RNA computes from the node's sockets rather than storing: Color
+# Balance's white points are its temperature and tint inputs, which are
+# exported as sockets already.
+_DERIVED_PROPS = frozenset({"input_whitepoint", "output_whitepoint"})
+
+
+def _has_sibling_output(node) -> bool:
+    """Whether the tree holds another output node of the same type.
+
+    Constructors leave ``is_active_output`` to Blender, which makes the first
+    output of each type active, so it only needs spelling out when there is a
+    choice. Setting it to True deactivates the others, so the active output is
+    rebuilt whatever order the nodes are created in.
+    """
+    tree = getattr(node, "id_data", None)
+    if tree is None:
+        return False
+    return any(
+        other.bl_idname == node.bl_idname and other != node for other in tree.nodes
+    )
+
+
 # ---------------------------------------------------------------------------
 # Factory reverse-mapping
 #

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/compositor/color.py

@@ -386,8 +386,8 @@ class ColorBalance(BaseNode):
         output_temperature: InputFloat = 6500.0,
         output_tint: InputFloat = 10.0,
         *,
-        input_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
-        output_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
+        input_whitepoint: tuple[float, float, float] | None = None,
+        output_whitepoint: tuple[float, float, float] | None = None,
     ):
         super().__init__()
         key_args = {
@@ -411,9 +411,12 @@ class ColorBalance(BaseNode):
             "Output Temperature": output_temperature,
             "Output Tint": output_tint,
         }
-        self.input_whitepoint = input_whitepoint
-        self.output_whitepoint = output_whitepoint
+
         self._establish_links(**key_args)
+        if input_whitepoint is not None:
+            self.input_whitepoint = input_whitepoint
+        if output_whitepoint is not None:
+            self.output_whitepoint = output_whitepoint
 
     @classmethod
     def lift_gamma_gain(
@@ -427,8 +430,8 @@ class ColorBalance(BaseNode):
         base_gain: InputFloat = 1.0,
         color_gain: InputColor = (1.0, 1.0, 1.0, 1.0),
         *,
-        input_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
-        output_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
+        input_whitepoint: tuple[float, float, float] | None = None,
+        output_whitepoint: tuple[float, float, float] | None = None,
     ) -> "ColorBalance":
         """Create Color Balance node with type 'Lift/Gamma/Gain'."""
         return cls(
@@ -457,8 +460,8 @@ class ColorBalance(BaseNode):
         base_slope: InputFloat = 1.0,
         color_slope: InputColor = (1.0, 1.0, 1.0, 1.0),
         *,
-        input_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
-        output_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
+        input_whitepoint: tuple[float, float, float] | None = None,
+        output_whitepoint: tuple[float, float, float] | None = None,
     ) -> "ColorBalance":
         """Create Color Balance node with type 'Offset/Power/Slope (ASC-CDL)'."""
         return cls(
@@ -485,8 +488,8 @@ class ColorBalance(BaseNode):
         output_temperature: InputFloat = 6500.0,
         output_tint: InputFloat = 10.0,
         *,
-        input_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
-        output_whitepoint: tuple[float, float, float] = (0.735, 0.735, 0.735),
+        input_whitepoint: tuple[float, float, float] | None = None,
+        output_whitepoint: tuple[float, float, float] | None = None,
     ) -> "ColorBalance":
         """Create Color Balance node with type 'White Point'."""
         return cls(

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/compositor/filter.py

@@ -616,10 +616,10 @@ class Defocus(BaseNode):
             "OCTAGON", "HEPTAGON", "HEXAGON", "PENTAGON", "SQUARE", "TRIANGLE", "CIRCLE"
         ] = "CIRCLE",
         angle: float = 0.0,
-        f_stop: float = 0.0,
-        blur_max: float = 0.0,
-        use_zbuffer: bool = True,
-        z_scale: float = 0.0,
+        f_stop: float = 128.0,
+        blur_max: float = 16.0,
+        use_zbuffer: bool = False,
+        z_scale: float = 1.0,
     ):
         super().__init__()
         key_args = {"Image": image, "Z": z}

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/compositor/manual.py

@@ -117,11 +117,11 @@ class Image(BaseNode):
     def __init__(
         self,
         image: Image | None = None,
-        frame_duration: int = 0,
-        frame_start: int = 0,
+        frame_duration: int = 1,
+        frame_start: int = 1,
         frame_offset: int = 0,
         use_cyclic: bool = False,
-        use_auto_refresh: bool = False,
+        use_auto_refresh: bool = True,
         layer: str | None = None,
         view: str | None = None,
     ):

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/compositor/output.py

@@ -38,8 +38,8 @@ class FileOutput(BaseNode):
         self,
         directory: str = "",
         file_name: str = "",
-        save_as_render: bool = False,
-        use_file_extension: bool = False,
+        save_as_render: bool = True,
+        use_file_extension: bool = True,
     ):
         super().__init__()
         key_args = {}

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/geometry/converter.py

@@ -5212,7 +5212,7 @@ class MapRange(BaseNode):
         to_max_float3: InputVector = (1.0, 1.0, 1.0),
         steps_float3: InputVector = (4.0, 4.0, 4.0),
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         interpolation_type: Literal[
             "LINEAR", "STEPPED", "SMOOTHSTEP", "SMOOTHERSTEP"
         ] = "LINEAR",
@@ -5247,7 +5247,7 @@ class MapRange(BaseNode):
         to_min: InputFloat = 0.0,
         to_max: InputFloat = 1.0,
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         data_type: Literal["FLOAT", "FLOAT_VECTOR"] = "FLOAT",
     ) -> "MapRange":
         """Create Map Range with operation 'Linear'. Linear interpolation between From Min and From Max values"""
@@ -5272,7 +5272,7 @@ class MapRange(BaseNode):
         to_max: InputFloat = 1.0,
         steps: InputFloat = 4.0,
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         data_type: Literal["FLOAT", "FLOAT_VECTOR"] = "FLOAT",
     ) -> "MapRange":
         """Create Map Range with operation 'Stepped Linear'. Stepped linear interpolation between From Min and From Max values"""
@@ -5297,7 +5297,7 @@ class MapRange(BaseNode):
         to_min: InputFloat = 0.0,
         to_max: InputFloat = 1.0,
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         data_type: Literal["FLOAT", "FLOAT_VECTOR"] = "FLOAT",
     ) -> "MapRange":
         """Create Map Range with operation 'Smooth Step'. Smooth Hermite edge interpolation between From Min and From Max values"""
@@ -5321,7 +5321,7 @@ class MapRange(BaseNode):
         to_min: InputFloat = 0.0,
         to_max: InputFloat = 1.0,
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         data_type: Literal["FLOAT", "FLOAT_VECTOR"] = "FLOAT",
     ) -> "MapRange":
         """Create Map Range with operation 'Smoother Step'. Smoother Hermite edge interpolation between From Min and From Max values"""
@@ -5345,7 +5345,7 @@ class MapRange(BaseNode):
         to_min: InputFloat = 0.0,
         to_max: InputFloat = 1.0,
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         interpolation_type: Literal[
             "LINEAR", "STEPPED", "SMOOTHSTEP", "SMOOTHERSTEP"
         ] = "LINEAR",
@@ -5371,7 +5371,7 @@ class MapRange(BaseNode):
         to_min: InputVector = (0.0, 0.0, 0.0),
         to_max: InputVector = (1.0, 1.0, 1.0),
         *,
-        clamp: bool = False,
+        clamp: bool = True,
         interpolation_type: Literal[
             "LINEAR", "STEPPED", "SMOOTHSTEP", "SMOOTHERSTEP"
         ] = "LINEAR",
@@ -6335,7 +6335,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ):
         super().__init__()
@@ -6387,7 +6387,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Float'."""
@@ -6431,7 +6431,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Vector'."""
@@ -6475,7 +6475,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Color'."""
@@ -6519,7 +6519,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Rotation'."""

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/geometry/geometry.py

@@ -5083,7 +5083,7 @@ class ResampleCurve(BaseNode):
         count: InputInteger = 10,
         length: InputFloat = 0.1,
         *,
-        keep_last_segment: bool = False,
+        keep_last_segment: bool = True,
     ):
         super().__init__()
         key_args = {

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/geometry/input.py

@@ -542,9 +542,7 @@ class Color(BaseNode):
         @property
         def o(self) -> _Outputs: ...
 
-    def __init__(
-        self, value: tuple[float, float, float, float] = (0.735, 0.735, 0.735, 1.0)
-    ):
+    def __init__(self, value: tuple[float, float, float, float] = (0.5, 0.5, 0.5, 1.0)):
         super().__init__()
         key_args = {}
         self.value = value
@@ -2300,7 +2298,7 @@ class Integer(BaseNode):
         @property
         def o(self) -> _Outputs: ...
 
-    def __init__(self, integer: int = 1):
+    def __init__(self, integer: int = 0):
         super().__init__()
         key_args = {}
         self.integer = integer

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/geometry/interface.py

@@ -442,11 +442,13 @@ class GroupOutput(BaseNode):
         @property
         def o(self) -> _Outputs: ...
 
-    def __init__(self, is_active_output: bool = False):
+    def __init__(self, is_active_output: bool | None = None):
         super().__init__()
         key_args = {}
-        self.is_active_output = is_active_output
+
         self._establish_links(**key_args)
+        if is_active_output is not None:
+            self.is_active_output = is_active_output
 
     @property
     def is_active_output(self) -> bool:
@@ -595,15 +597,15 @@ class TransformGizmo(BaseNode):
         position: InputVector = (0.0, 0.0, 0.0),
         rotation: InputRotation = (0.0, 0.0, 0.0),
         *,
-        use_translation_x: bool = False,
-        use_translation_y: bool = False,
-        use_translation_z: bool = False,
-        use_rotation_x: bool = False,
-        use_rotation_y: bool = False,
-        use_rotation_z: bool = False,
-        use_scale_x: bool = False,
-        use_scale_y: bool = False,
-        use_scale_z: bool = False,
+        use_translation_x: bool = True,
+        use_translation_y: bool = True,
+        use_translation_z: bool = True,
+        use_rotation_x: bool = True,
+        use_rotation_y: bool = True,
+        use_rotation_z: bool = True,
+        use_scale_x: bool = True,
+        use_scale_y: bool = True,
+        use_scale_z: bool = True,
     ):
         super().__init__()
         key_args = {"Value": value, "Position": position, "Rotation": rotation}

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/geometry/texture.py

@@ -684,7 +684,7 @@ class MagicTexture(BaseNode):
         scale: InputFloat = 5.0,
         distortion: InputFloat = 1.0,
         *,
-        turbulence_depth: int = 0,
+        turbulence_depth: int = 2,
     ):
         super().__init__()
         key_args = {"Vector": vector, "Scale": scale, "Distortion": distortion}
@@ -802,7 +802,7 @@ class NoiseTexture(BaseNode):
         gain: InputFloat = 1.0,
         distortion: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
         noise_type: Literal[
             "MULTIFRACTAL",
             "RIDGED_MULTIFRACTAL",
@@ -810,7 +810,7 @@ class NoiseTexture(BaseNode):
             "FBM",
             "HETERO_TERRAIN",
         ] = "FBM",
-        normalize: bool = False,
+        normalize: bool = True,
     ):
         super().__init__()
         key_args = {
@@ -824,7 +824,8 @@ class NoiseTexture(BaseNode):
             "Gain": gain,
             "Distortion": distortion,
         }
-        self.noise_dimensions = noise_dimensions
+        if noise_dimensions is not None:
+            self.noise_dimensions = noise_dimensions
         self.noise_type = noise_type
         self.normalize = normalize
         self._establish_links(**key_args)
@@ -839,7 +840,7 @@ class NoiseTexture(BaseNode):
         lacunarity: InputFloat = 2.0,
         distortion: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
     ) -> "NoiseTexture":
         """Create Noise Texture with operation 'Multifractal'. More uneven result (varies with location), more similar to a real terrain"""
         return cls(
@@ -865,7 +866,7 @@ class NoiseTexture(BaseNode):
         gain: InputFloat = 1.0,
         distortion: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
     ) -> "NoiseTexture":
         """Create Noise Texture with operation 'Ridged Multifractal'. Create sharp peaks"""
         return cls(
@@ -893,7 +894,7 @@ class NoiseTexture(BaseNode):
         gain: InputFloat = 1.0,
         distortion: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
     ) -> "NoiseTexture":
         """Create Noise Texture with operation 'Hybrid Multifractal'. Create peaks and valleys with different roughness values"""
         return cls(
@@ -919,8 +920,8 @@ class NoiseTexture(BaseNode):
         lacunarity: InputFloat = 2.0,
         distortion: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
-        normalize: bool = False,
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
+        normalize: bool = True,
     ) -> "NoiseTexture":
         """Create Noise Texture with operation 'fBM'. The standard fractal Perlin noise"""
         return cls(
@@ -946,7 +947,7 @@ class NoiseTexture(BaseNode):
         offset: InputFloat = 0.0,
         distortion: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
     ) -> "NoiseTexture":
         """Create Noise Texture with operation 'Hetero Terrain'. Similar to Hybrid Multifractal creates a heterogeneous terrain, but with the likeness of river channels"""
         return cls(
@@ -1117,7 +1118,7 @@ class VoronoiTexture(BaseNode):
         exponent: InputFloat = 0.5,
         randomness: InputFloat = 1.0,
         *,
-        voronoi_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        voronoi_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
         distance: Literal[
             "EUCLIDEAN", "MANHATTAN", "CHEBYCHEV", "MINKOWSKI"
         ] = "EUCLIDEAN",
@@ -1138,7 +1139,8 @@ class VoronoiTexture(BaseNode):
             "Exponent": exponent,
             "Randomness": randomness,
         }
-        self.voronoi_dimensions = voronoi_dimensions
+        if voronoi_dimensions is not None:
+            self.voronoi_dimensions = voronoi_dimensions
         self.distance = distance
         self.feature = feature
         self.normalize = normalize
@@ -1435,11 +1437,12 @@ class WhiteNoiseTexture(BaseNode):
         vector: InputVector = None,
         w: InputFloat = 0.0,
         *,
-        noise_dimensions: Literal["1D", "2D", "3D", "4D"] = "3D",
+        noise_dimensions: Literal["1D", "2D", "3D", "4D"] | None = None,
     ):
         super().__init__()
         key_args = {"Vector": vector, "W": w}
-        self.noise_dimensions = noise_dimensions
+        if noise_dimensions is not None:
+            self.noise_dimensions = noise_dimensions
         self._establish_links(**key_args)
 
     @property

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/shader/converter.py

@@ -409,7 +409,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ):
         super().__init__()
@@ -461,7 +461,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Float'."""
@@ -505,7 +505,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Vector'."""
@@ -549,7 +549,7 @@ class Mix(BaseNode):
             "COLOR",
             "VALUE",
         ] = "MIX",
-        clamp_factor: bool = False,
+        clamp_factor: bool = True,
         clamp_result: bool = False,
     ) -> "Mix":
         """Create Mix with operation 'Color'."""

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/shader/input.py

@@ -78,7 +78,7 @@ class AmbientOcclusion(BaseNode):
         distance: InputFloat = 1.0,
         normal: InputVector = None,
         *,
-        samples: int = 0,
+        samples: int = 16,
         inside: bool = False,
         only_local: bool = False,
     ):
@@ -164,7 +164,7 @@ class Bevel(BaseNode):
         radius: InputFloat = 0.05,
         normal: InputVector = None,
         *,
-        samples: int = 0,
+        samples: int = 4,
     ):
         super().__init__()
         key_args = {"Radius": radius, "Normal": normal}

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/shader/output.py

@@ -115,14 +115,15 @@ class LightOutput(BaseNode):
         self,
         surface: InputShader = None,
         *,
-        is_active_output: bool = False,
+        is_active_output: bool | None = None,
         target: Literal["ALL", "EEVEE", "CYCLES"] = "ALL",
     ):
         super().__init__()
         key_args = {"Surface": surface}
-        self.is_active_output = is_active_output
         self.target = target
         self._establish_links(**key_args)
+        if is_active_output is not None:
+            self.is_active_output = is_active_output
 
     @property
     def is_active_output(self) -> bool:
@@ -198,7 +199,7 @@ class LineStyleOutput(BaseNode):
         alpha: InputFloat = 1.0,
         alpha_fac: InputFloat = 1.0,
         *,
-        is_active_output: bool = False,
+        is_active_output: bool | None = None,
         target: Literal["ALL", "EEVEE", "CYCLES"] = "ALL",
         blend_type: Literal[
             "MIX",
@@ -231,12 +232,13 @@ class LineStyleOutput(BaseNode):
             "Alpha": alpha,
             "Alpha Fac": alpha_fac,
         }
-        self.is_active_output = is_active_output
         self.target = target
         self.blend_type = blend_type
         self.use_alpha = use_alpha
         self.use_clamp = use_clamp
         self._establish_links(**key_args)
+        if is_active_output is not None:
+            self.is_active_output = is_active_output
 
     @property
     def is_active_output(self) -> bool:
@@ -381,7 +383,7 @@ class MaterialOutput(BaseNode):
         displacement: InputVector = None,
         thickness: InputFloat = None,
         *,
-        is_active_output: bool = False,
+        is_active_output: bool | None = None,
         target: Literal["ALL", "EEVEE", "CYCLES"] = "ALL",
     ):
         super().__init__()
@@ -391,9 +393,10 @@ class MaterialOutput(BaseNode):
             "Displacement": displacement,
             "Thickness": thickness,
         }
-        self.is_active_output = is_active_output
         self.target = target
         self._establish_links(**key_args)
+        if is_active_output is not None:
+            self.is_active_output = is_active_output
 
     @property
     def is_active_output(self) -> bool:
@@ -455,14 +458,15 @@ class WorldOutput(BaseNode):
         surface: InputShader = None,
         volume: InputShader = None,
         *,
-        is_active_output: bool = False,
+        is_active_output: bool | None = None,
         target: Literal["ALL", "EEVEE", "CYCLES"] = "ALL",
     ):
         super().__init__()
         key_args = {"Surface": surface, "Volume": volume}
-        self.is_active_output = is_active_output
         self.target = target
         self._establish_links(**key_args)
+        if is_active_output is not None:
+            self.is_active_output = is_active_output
 
     @property
     def is_active_output(self) -> bool:

{nodebpy-520.34.1 → nodebpy-520.35.1}/src/nodebpy/nodes/shader/texture.py

@@ -330,8 +330,8 @@ class SkyTexture(BaseNode):
         aerosol_density: float = 1.0,
         ozone_density: float = 1.0,
         sun_direction: tuple[float, float, float] = (0.0, 0.0, 1.0),
-        turbidity: float = 0.0,
-        ground_albedo: float = 0.0,
+        turbidity: float = 2.2,
+        ground_albedo: float = 0.3,
     ):
         super().__init__()
         key_args = {"Vector": vector}
@@ -412,7 +412,7 @@ class SkyTexture(BaseNode):
         vector: InputVector = None,
         *,
         sun_direction: tuple[float, float, float] = (0.0, 0.0, 1.0),
-        turbidity: float = 0.0,
+        turbidity: float = 2.2,
     ) -> "SkyTexture":
         """Create Sky Texture with operation 'Preetham'. Preetham 1999 (Legacy)"""
         return cls(
@@ -428,8 +428,8 @@ class SkyTexture(BaseNode):
         vector: InputVector = None,
         *,
         sun_direction: tuple[float, float, float] = (0.0, 0.0, 1.0),
-        turbidity: float = 0.0,
-        ground_albedo: float = 0.0,
+        turbidity: float = 2.2,
+        ground_albedo: float = 0.3,
     ) -> "SkyTexture":
         """Create Sky Texture with operation 'Hosek / Wilkie'. Hosek / Wilkie 2012 (Legacy)"""
         return cls(