nodebpy 520.9.0__tar.gz → 520.10.0__tar.gz

{nodebpy-520.9.0 → nodebpy-520.10.0}/PKG-INFO

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

{nodebpy-520.9.0 → nodebpy-520.10.0}/pyproject.toml

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

{nodebpy-520.9.0 → nodebpy-520.10.0}/src/nodebpy/assets/_codegen.py

@@ -181,11 +181,10 @@ def _collect(
     group's *inputs*, whose parameters are typed from them.
     """
     descriptions = descriptions or {}
-    raw = [
-        s
-        for s in sockets
-        if s.identifier != "__extend__" and not getattr(s, "is_inactive", False)
-    ]
+    # Keep inactive sockets: socket-usage inference deactivates inputs that the
+    # current node options (e.g. a menu selection) leave unused, but a caller
+    # may set those options differently, so the API must expose every input.
+    raw = [s for s in sockets if s.identifier != "__extend__"]
     # The accessor resolves attribute names by identifier first, then name, so a
     # group socket's readable name works as the attr/param when it's unambiguous;
     # fall back to the opaque-but-unique identifier only on a name collision.
@@ -213,6 +212,43 @@ def _collect(
     return out
 
 
+def _introspect_group(group, name: str, library_source: str) -> _AssetClass:
+    """Introspect the node group ``group`` (a ``bpy.types.NodeTree``) into an
+    :class:`_AssetClass` record by instantiating it on a throwaway host node.
+
+    ``group`` is deliberately unannotated: the stubs type interface items and
+    ``node_groups.new`` too narrowly for the runtime attributes used here.
+    """
+    host = bpy.data.node_groups.new("_introspect_host", group.bl_idname)
+    try:
+        node_type = {
+            "GeometryNodeTree": "GeometryNodeGroup",
+            "ShaderNodeTree": "ShaderNodeGroup",
+            "CompositorNodeTree": "CompositorNodeGroup",
+        }[group.bl_idname]
+        node = host.nodes.new(node_type)
+        node.node_tree = group  # ty: ignore[unresolved-attribute]
+        # Tooltips live on the tree *interface* items, not on the node's
+        # sockets — collect them by identifier so the generated docstrings
+        # can use the asset author's own wording.
+        descriptions = {
+            item.identifier: item.description or ""
+            for item in group.interface.items_tree
+            if item.item_type == "SOCKET"
+        }
+        return _AssetClass(
+            class_name=_class_name(name),
+            asset_name=name,
+            description=(group.description or name).strip(),
+            library_source=library_source,
+            tree_idname=group.bl_idname,
+            inputs=_collect(node.inputs, descriptions, menus=True),
+            outputs=_collect(node.outputs, descriptions),
+        )
+    finally:
+        bpy.data.node_groups.remove(host)
+
+
 def _introspect(library: AssetLibrary, names: set[str] | None) -> list[_AssetClass]:
     """Append each requested group from the library and introspect its
     interface into :class:`_AssetClass` records."""
@@ -236,37 +272,7 @@ def _introspect(library: AssetLibrary, names: set[str] | None) -> list[_AssetCla
         ):
             dst.node_groups = [name]
         group = dst.node_groups[0]
-
-        host = bpy.data.node_groups.new("_introspect_host", group.bl_idname)
-        try:
-            node_type = {
-                "GeometryNodeTree": "GeometryNodeGroup",
-                "ShaderNodeTree": "ShaderNodeGroup",
-                "CompositorNodeTree": "CompositorNodeGroup",
-            }[group.bl_idname]
-            node = host.nodes.new(node_type)
-            node.node_tree = group  # ty: ignore[unresolved-attribute]
-            # Tooltips live on the tree *interface* items, not on the node's
-            # sockets — collect them by identifier so the generated docstrings
-            # can use the asset author's own wording.
-            descriptions = {
-                item.identifier: item.description or ""
-                for item in group.interface.items_tree
-                if item.item_type == "SOCKET"
-            }
-            classes.append(
-                _AssetClass(
-                    class_name=_class_name(name),
-                    asset_name=name,
-                    description=(group.description or name).strip(),
-                    library_source=library_source,
-                    tree_idname=group.bl_idname,
-                    inputs=_collect(node.inputs, descriptions, menus=True),
-                    outputs=_collect(node.outputs, descriptions),
-                )
-            )
-        finally:
-            bpy.data.node_groups.remove(host)
+        classes.append(_introspect_group(group, name, library_source))
     return classes
 
 

{nodebpy-520.9.0 → nodebpy-520.10.0}/src/nodebpy/nodes/compositor/assets.py

@@ -35,8 +35,16 @@ class ChromaticAberration(AssetCompositorGroup):
         Image
     type : InputMenu | Literal["Offset", "Scale", "Directional Blur", "Lens Dispersion"]
         Different styles of aberrations
+    axis : InputMenu | Literal["Vertical", "Horizontal"]
+        Direction of the aberration effect
     factor : InputFloat
         The intensity of the aberration effect
+    center : InputVector
+        The position the transformations pivot around, in normalized coordinates. 0 means the lower left corner and 1 means the upper right corner of the image.
+    samples : InputInteger
+        The number of samples used to compute the blur. The more samples the smoother the result, at the expense of more compute time. The actual number of samples is two to the power of this input, so it increases exponentially.
+    fit : InputBoolean
+        Scale the image such that it fits entirely in the frame, leaving no empty spaces at the corners
 
     Inputs
     ------
@@ -44,8 +52,16 @@ class ChromaticAberration(AssetCompositorGroup):
         Image
     i.type : MenuSocket
         Different styles of aberrations
+    i.axis : MenuSocket
+        Direction of the aberration effect
     i.factor : FloatSocket
         The intensity of the aberration effect
+    i.center : VectorSocket
+        The position the transformations pivot around, in normalized coordinates. 0 means the lower left corner and 1 means the upper right corner of the image.
+    i.samples : IntegerSocket
+        The number of samples used to compute the blur. The more samples the smoother the result, at the expense of more compute time. The actual number of samples is two to the power of this input, so it increases exponentially.
+    i.fit : BooleanSocket
+        Scale the image such that it fits entirely in the frame, leaving no empty spaces at the corners
 
     Outputs
     -------
@@ -62,8 +78,16 @@ class ChromaticAberration(AssetCompositorGroup):
         """Image"""
         type: MenuSocket
         """Different styles of aberrations"""
+        axis: MenuSocket
+        """Direction of the aberration effect"""
         factor: FloatSocket
         """The intensity of the aberration effect"""
+        center: VectorSocket
+        """The position the transformations pivot around, in normalized coordinates. 0 means the lower left corner and 1 means the upper right corner of the image."""
+        samples: IntegerSocket
+        """The number of samples used to compute the blur. The more samples the smoother the result, at the expense of more compute time. The actual number of samples is two to the power of this input, so it increases exponentially."""
+        fit: BooleanSocket
+        """Scale the image such that it fits entirely in the frame, leaving no empty spaces at the corners"""
 
     class _Outputs(SocketAccessor):
         image: ColorSocket
@@ -81,9 +105,23 @@ class ChromaticAberration(AssetCompositorGroup):
         image: InputColor = None,
         type: InputMenu
         | Literal["Offset", "Scale", "Directional Blur", "Lens Dispersion"] = "Scale",
+        axis: InputMenu | Literal["Vertical", "Horizontal"] = "Horizontal",
         factor: InputFloat = 0.2,
+        center: InputVector = None,
+        samples: InputInteger = 3,
+        fit: InputBoolean = False,
     ):
-        super().__init__(**{"Socket_1": image, "Socket_6": type, "Socket_2": factor})
+        super().__init__(
+            **{
+                "Socket_1": image,
+                "Socket_6": type,
+                "Socket_8": axis,
+                "Socket_2": factor,
+                "Socket_3": center,
+                "Socket_4": samples,
+                "Socket_7": fit,
+            }
+        )
 
 
 class CombineCylindrical(AssetCompositorGroup):
@@ -218,8 +256,28 @@ class FilmGrain(AssetCompositorGroup):
         Amount of mixing between the effect and original image
     preset : InputMenu | Literal["8 mm Caffenol", "8 mm Home Movie", "Super 8 mm", "16 mm Broadcast", "16 mm Indie Cinema", "35 mm Portra 400", "Super 35 mm", "70 mm Cinema", "Custom"]
         Preset
+    film_gauge : InputMenu | Literal["8 mm", "16 mm", "35 mm", "70 mm"]
+        Film Gauge
+    style : InputMenu | Literal["Xpro Sharp", "Cinematic Gritty", "Home Movie", "Studio Broadcast", "Pro Photography", "Cinematic Soft", "Custom Style"]
+        Style
     animated : InputBoolean
         Should the noise change frame to frame
+    iso : InputInteger
+        ISO
+    softness : InputFloat
+        Halation-style softening: edges "bleed" and become smoother, adds bloom and noise that is somewhat pattern-aware
+    acutance : InputFloat
+        Sharpens large details and adds a halo around objects
+    coarseness : InputFloat
+        Emulsion roughness, also adds grain clamping
+    patchiness : InputFloat
+        Smoothness of the film substrate. High values contribute to a stroboscope effect when animating.
+    saturation : InputFloat
+        Noise colorfulness
+    luma_bias : InputFloat
+        Luma bias
+    texture_scale : InputFloat
+        Texture Scale
 
     Inputs
     ------
@@ -229,8 +287,28 @@ class FilmGrain(AssetCompositorGroup):
         Amount of mixing between the effect and original image
     i.preset : MenuSocket
         Preset
+    i.film_gauge : MenuSocket
+        Film Gauge
+    i.style : MenuSocket
+        Style
     i.animated : BooleanSocket
         Should the noise change frame to frame
+    i.iso : IntegerSocket
+        ISO
+    i.softness : FloatSocket
+        Halation-style softening: edges "bleed" and become smoother, adds bloom and noise that is somewhat pattern-aware
+    i.acutance : FloatSocket
+        Sharpens large details and adds a halo around objects
+    i.coarseness : FloatSocket
+        Emulsion roughness, also adds grain clamping
+    i.patchiness : FloatSocket
+        Smoothness of the film substrate. High values contribute to a stroboscope effect when animating.
+    i.saturation : FloatSocket
+        Noise colorfulness
+    i.luma_bias : FloatSocket
+        Luma bias
+    i.texture_scale : FloatSocket
+        Texture Scale
 
     Outputs
     -------
@@ -249,8 +327,28 @@ class FilmGrain(AssetCompositorGroup):
         """Amount of mixing between the effect and original image"""
         preset: MenuSocket
         """Preset"""
+        film_gauge: MenuSocket
+        """Film Gauge"""
+        style: MenuSocket
+        """Style"""
         animated: BooleanSocket
         """Should the noise change frame to frame"""
+        iso: IntegerSocket
+        """ISO"""
+        softness: FloatSocket
+        """Halation-style softening: edges "bleed" and become smoother, adds bloom and noise that is somewhat pattern-aware"""
+        acutance: FloatSocket
+        """Sharpens large details and adds a halo around objects"""
+        coarseness: FloatSocket
+        """Emulsion roughness, also adds grain clamping"""
+        patchiness: FloatSocket
+        """Smoothness of the film substrate. High values contribute to a stroboscope effect when animating."""
+        saturation: FloatSocket
+        """Noise colorfulness"""
+        luma_bias: FloatSocket
+        """Luma bias"""
+        texture_scale: FloatSocket
+        """Texture Scale"""
 
     class _Outputs(SocketAccessor):
         result: ColorSocket
@@ -279,14 +377,43 @@ class FilmGrain(AssetCompositorGroup):
             "70 mm Cinema",
             "Custom",
         ] = "Super 8 mm",
+        film_gauge: InputMenu | Literal["8 mm", "16 mm", "35 mm", "70 mm"] = "16 mm",
+        style: InputMenu
+        | Literal[
+            "Xpro Sharp",
+            "Cinematic Gritty",
+            "Home Movie",
+            "Studio Broadcast",
+            "Pro Photography",
+            "Cinematic Soft",
+            "Custom Style",
+        ] = "Studio Broadcast",
         animated: InputBoolean = False,
+        iso: InputInteger = 400,
+        softness: InputFloat = 0.5,
+        acutance: InputFloat = 0.5,
+        coarseness: InputFloat = 0.5,
+        patchiness: InputFloat = 0.5,
+        saturation: InputFloat = 0.5,
+        luma_bias: InputFloat = 0.5,
+        texture_scale: InputFloat = 0.5,
     ):
         super().__init__(
             **{
                 "Socket_1": input,
                 "Socket_7": factor,
                 "Socket_64": preset,
+                "Socket_46": film_gauge,
+                "Socket_47": style,
                 "Socket_10": animated,
+                "Socket_56": iso,
+                "Socket_52": softness,
+                "Socket_70": acutance,
+                "Socket_53": coarseness,
+                "Socket_54": patchiness,
+                "Socket_55": saturation,
+                "Socket_65": luma_bias,
+                "Socket_73": texture_scale,
             }
         )
 
@@ -395,6 +522,8 @@ class Retime(AssetCompositorGroup):
         Multiply the current scene frame by this factor
     cyclic : InputBoolean
         Restart from start frame when Cycle Length is reached
+    cycle_length : InputInteger
+        Number of frames to cycle through. Not affected by Speed.
 
     Inputs
     ------
@@ -406,6 +535,8 @@ class Retime(AssetCompositorGroup):
         Multiply the current scene frame by this factor
     i.cyclic : BooleanSocket
         Restart from start frame when Cycle Length is reached
+    i.cycle_length : IntegerSocket
+        Number of frames to cycle through. Not affected by Speed.
 
     Outputs
     -------
@@ -426,6 +557,8 @@ class Retime(AssetCompositorGroup):
         """Multiply the current scene frame by this factor"""
         cyclic: BooleanSocket
         """Restart from start frame when Cycle Length is reached"""
+        cycle_length: IntegerSocket
+        """Number of frames to cycle through. Not affected by Speed."""
 
     class _Outputs(SocketAccessor):
         frame: IntegerSocket
@@ -444,6 +577,7 @@ class Retime(AssetCompositorGroup):
         step: InputInteger = 1,
         speed: InputFloat = 1.0,
         cyclic: InputBoolean = False,
+        cycle_length: InputInteger = 10,
     ):
         super().__init__(
             **{
@@ -451,6 +585,7 @@ class Retime(AssetCompositorGroup):
                 "Socket_13": step,
                 "Socket_14": speed,
                 "Socket_11": cyclic,
+                "Socket_3": cycle_length,
             }
         )