fix detection of all inputs (#130)

Some were potentially hidden depending on intniial node setting
configuration.

Author: BradyAJohnston

docs/changelog.qmd

@@ -2,6 +2,17 @@
 title: Changelog
 ---
 
+## v520.10.0 - 2026-08-03
+
+### Fixes
+- **Asset generation exposes every interface input** — introspecting an asset node group skipped inputs that Blender's socket-usage inference marks inactive under the group's current node options (e.g. a Menu Switch selection deactivating the inputs of the branches not taken), so those parameters were silently missing from the generated `__init__`. All interface inputs are now generated; the bundled essentials APIs were regenerated and pick up the previously hidden menu-gated inputs (e.g. the compositor `ChromaticAberration` gains `axis`, `center`, `samples` and `fit`).
+
+## v520.9.0 - 2026-07-22
+
+### Enhancements
+- Generated asset classes now carry numpy-style docstrings (description, `Parameters`, `Inputs`, `Outputs`) built from the asset's own socket tooltips, so editors show documentation alongside the type hints. Pass `docstrings=False` to `generate_asset_api` (or `--no-docstrings` to `python -m nodebpy.assets`) for the terser output.
+- Menu sockets on generated asset classes are typed with the items they actually offer — `shape: InputMenu | Literal["Line", "Circle", "Curve", "Transform"]` — matching how menu sockets are already typed on the built-in nodes.
+
 ## v520.8.0 - 2026-07-17
 
 ### Enhancements
@@ -42,8 +53,6 @@ python -m nodebpy.assets -b my_assets.blend -o my_addon/nodes/
 
 ### Enhancements
 - Changed the linking of asset node groups for the `_AssetGroupMixin` to be 'linked & packed' by default
-- Generated asset classes now carry numpy-style docstrings (description, `Parameters`, `Inputs`, `Outputs`) built from the asset's own socket tooltips, so editors show documentation alongside the type hints. Pass `docstrings=False` to `generate_asset_api` (or `--no-docstrings` to `python -m nodebpy.assets`) for the terser output.
-- Menu sockets on generated asset classes are typed with the items they actually offer — `shape: InputMenu | Literal["Line", "Circle", "Curve", "Transform"]` — matching how menu sockets are already typed on the built-in nodes.
 
 ## v520.4.0 - 2026-06-19
 

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 = [

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
 
 

src/nodebpy/nodes/compositor/assets.py

@@ -35,17 +35,33 @@ 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
     ------
     i.image : ColorSocket
         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 _Inputs(SocketAccessor):
         """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 @@ def __init__(
         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 _Inputs(SocketAccessor):
         """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 @@ def __init__(
             "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 _Inputs(SocketAccessor):
         """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,13 +577,15 @@ def __init__(
         step: InputInteger = 1,
         speed: InputFloat = 1.0,
         cyclic: InputBoolean = False,
+        cycle_length: InputInteger = 10,
     ):
         super().__init__(
             **{
                 "Socket_4": offset,
                 "Socket_13": step,
                 "Socket_14": speed,
                 "Socket_11": cyclic,
+                "Socket_3": cycle_length,
             }
         )