nodebpy 520.30.1__tar.gz → 520.31.0__tar.gz

{nodebpy-520.30.1 → nodebpy-520.31.0}/PKG-INFO

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

{nodebpy-520.30.1 → nodebpy-520.31.0}/pyproject.toml

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

{nodebpy-520.30.1 → nodebpy-520.31.0}/src/nodebpy/builder/accessor.py

@@ -180,6 +180,21 @@ class SocketAccessor:
             s for s in self._collection if self._ignore_visibility or s.is_icon_visible
         ]
 
+    @property
+    def _inactive_fallback(self) -> list[NodeSocket]:
+        """Inactive inputs that may still be linked, for when no active input
+        fits. Only nodes on the ``_allow_innactive_sockets`` allowlist qualify:
+        a group input used behind an internal switch (``FadeGeometry(fade=0)``)
+        polls inactive but is still shown and linkable in the UI.
+        """
+        if self._direction != "input" or not _allow_innactive_sockets(self._node):
+            return []
+        return [
+            s
+            for s in self._collection
+            if s.is_inactive and s.is_icon_visible and (not s.links or s.is_multi_input)
+        ]
+
     def _best_match(self, socket_type: str) -> NodeSocket:
         """Find the best compatible socket for the given type."""
         from ..types import SOCKET_COMPATIBILITY

{nodebpy-520.30.1 → nodebpy-520.31.0}/src/nodebpy/builder/asset.py

@@ -110,8 +110,7 @@ class _AssetGroupMixin:
         (a merged dump class) rather than the appending-only placeholder."""
         return cls._build_group is not _AssetGroupMixin._build_group
 
-    @classmethod
-    def create_group(cls) -> Any:
+    def _create_group(self) -> Any:
         """Append the named asset group from the library and return its tree,
         reusing a previously-appended group of the same name and tree type.
 
@@ -125,15 +124,16 @@ class _AssetGroupMixin:
         when the ``.blend`` is not on disk (a source checkout that hasn't
         built it yet).
         """
+        cls = type(self)
         if _build_from_source_depth and cls._has_build_source():
-            return super().create_group()  # ty: ignore[unresolved-attribute]
+            return super()._create_group()  # ty: ignore[unresolved-attribute]
         existing = bpy.data.node_groups.get(cls._asset_name)
         if existing is not None and existing.bl_idname == cls._tree_idname:
             return existing
         path = cls._library.path()
         if not os.path.exists(path):
             if cls._has_build_source():
-                return super().create_group()  # ty: ignore[unresolved-attribute]
+                return super()._create_group()  # ty: ignore[unresolved-attribute]
             raise FileNotFoundError(f"Asset library not found: {path}")
         with bpy.data.libraries.load(path, link=True, pack=True, assets_only=True) as (  # ty: ignore[invalid-context-manager]
             src,

{nodebpy-520.30.1 → nodebpy-520.31.0}/src/nodebpy/builder/mixins.py

@@ -259,7 +259,6 @@ class LinkingMixin:
         from ..builder.socket import Socket
         from ..types import PREFER_FIRST_SOCKET, SOCKET_COMPATIBILITY
 
-        possible_combos = []
         if isinstance(source, BaseNode):
             outputs = source.o._available
         elif isinstance(source, NodeSocket):
@@ -286,44 +285,57 @@ class LinkingMixin:
         ):
             return inputs[0], outputs[0]
 
-        # Try first available input first — if the output type matches it exactly,
-        # or is a "preferred" implicit conversion (e.g. float→color, vector→color),
-        # use the first socket rather than searching for a better-typed later one.
-        # This keeps float→Image working in the compositor instead of drifting to
-        # a float Factor socket that scores higher on raw compatibility.
-        # Pairs not in PREFER_FIRST_SOCKET (e.g. VALUE→BOOLEAN, VECTOR→ROTATION)
-        # fall through to the ranked search below.
-        if inputs:
-            first_input = inputs[0]
+        def best_pair(inputs: list[NodeSocket]) -> tuple[NodeSocket, NodeSocket] | None:
+            possible_combos = []
+            # Try first available input first — if the output type matches it exactly,
+            # or is a "preferred" implicit conversion (e.g. float→color, vector→color),
+            # use the first socket rather than searching for a better-typed later one.
+            # This keeps float→Image working in the compositor instead of drifting to
+            # a float Factor socket that scores higher on raw compatibility.
+            # Pairs not in PREFER_FIRST_SOCKET (e.g. VALUE→BOOLEAN, VECTOR→ROTATION)
+            # fall through to the ranked search below.
+            if inputs:
+                first_input = inputs[0]
+                for output in outputs:
+                    if first_input.type == output.type:
+                        return first_input, output
+                    if (output.type, first_input.type) in PREFER_FIRST_SOCKET:
+                        return first_input, output
+
             for output in outputs:
-                if first_input.type == output.type:
-                    return first_input, output
-                if (output.type, first_input.type) in PREFER_FIRST_SOCKET:
-                    return first_input, output
-
-        for output in outputs:
-            compat_sockets = SOCKET_COMPATIBILITY.get(output.type, ())
-            for input in inputs:
-                if input.type == output.type:
-                    return input, output
-
-                if input.type in compat_sockets:
-                    possible_combos.append(
-                        (compat_sockets.index(input.type), (input, output))
-                    )
-
-        if possible_combos:
-            return min(possible_combos, key=lambda x: x[0])[1]
-
-        # A node with a virtual ``__extend__`` input (Viewer, …) accepts any
-        # source: linking to it makes Blender create a typed socket. Fall back
-        # to it when nothing else matched, pairing with the source's first
-        # available output.
-        extend = next(
-            (i for i in inputs if i.identifier.startswith("__extend__")), None
-        )
-        if extend is not None and outputs:
-            return extend, outputs[0]
+                compat_sockets = SOCKET_COMPATIBILITY.get(output.type, ())
+                for input in inputs:
+                    if input.type == output.type:
+                        return input, output
+
+                    if input.type in compat_sockets:
+                        possible_combos.append(
+                            (compat_sockets.index(input.type), (input, output))
+                        )
+
+            if possible_combos:
+                return min(possible_combos, key=lambda x: x[0])[1]
+
+            # A node with a virtual ``__extend__`` input (Viewer, …) accepts any
+            # source: linking to it makes Blender create a typed socket. Fall back
+            # to it when nothing else matched, pairing with the source's first
+            # available output.
+            extend = next(
+                (i for i in inputs if i.identifier.startswith("__extend__")), None
+            )
+            if extend is not None and outputs:
+                return extend, outputs[0]
+            return None
+
+        pair = best_pair(inputs)
+        # Nothing active fits: fall back to inactive inputs Blender still lets
+        # the user link (a group input unused at the current values).
+        if pair is None and isinstance(target, BaseNode):
+            fallback = target.i._inactive_fallback
+            if fallback:
+                pair = best_pair(fallback)
+        if pair is not None:
+            return pair
 
         src_name = getattr(getattr(source, "node", None), "name", repr(source))
         tgt_name = getattr(getattr(target, "node", None), "name", repr(target))

{nodebpy-520.30.1 → nodebpy-520.31.0}/src/nodebpy/builder/node.py

@@ -474,28 +474,37 @@ class NodeGroupBuilder[T: bpy.types.NodeTree](BaseNode, ABC):
         directly (e.g. assigned to a node's ``node_tree``) instead of being
         created by constructing the class inside a tree.
         """
-        existing = bpy.data.node_groups.get(cls._name)
+        # Only the inner tree is needed (no group *node*), so skip __init__,
+        # which would require an active context to create a node.
+        return cls.__new__(cls)._create_group()
+
+    def _group_name(self) -> str:
+        """Name of the inner tree. Override when instance state set before
+        ``super().__init__()`` (e.g. a data type) selects a variant, so each
+        variant builds and reuses its own tree."""
+        return self._name
+
+    def _create_group(self) -> T:
+        name = self._group_name()
+        existing = bpy.data.node_groups.get(name)
         if existing is not None:
-            if existing.bl_idname != cls._tree_idname:
+            if existing.bl_idname != self._tree_idname:
                 raise TypeError(
-                    f"Node group '{cls._name}' already exists as "
-                    f"{existing.bl_idname}, not {cls._tree_idname}. "
+                    f"Node group '{name}' already exists as "
+                    f"{existing.bl_idname}, not {self._tree_idname}. "
                     f"Use a unique _name for this group."
                 )
             return cast(T, existing)
-        # Only the inner tree is needed (no group *node*), so skip __init__,
-        # which would require an active context to create a node.
-        builder = cls.__new__(cls)
-        with TreeBuilder(cls._name, tree_type=cls._tree_idname) as tree:
-            builder._build_group(tree)
-        tree.tree.color_tag = cls._color_tag
-        for key, value in cls._tree_properties.items():
+        with TreeBuilder(name, tree_type=self._tree_idname) as tree:
+            self._build_group(tree)
+        tree.tree.color_tag = self._color_tag
+        for key, value in self._tree_properties.items():
             try:
                 setattr(tree.tree, key, value)
             except (AttributeError, TypeError):
                 # A property this Blender version doesn't have (or types
                 # differently) — skip rather than fail the whole build.
-                print(f"  {cls._name}: skipping tree property {key!r}")
+                print(f"  {name}: skipping tree property {key!r}")
         return cast(T, tree.tree)
 
 
@@ -512,7 +521,7 @@ class CustomGeometryGroup(NodeGroupBuilder[GeometryNodeTree]):
         return self.node.node_tree
 
     def _setup_node_group(self) -> None:
-        self.node.node_tree = self.create_group()
+        self.node.node_tree = self._create_group()
         self.node.warning_propagation = self._warning_propagation
 
 
@@ -529,7 +538,7 @@ class CustomShaderGroup(NodeGroupBuilder[ShaderNodeTree]):
         return self.node.node_tree
 
     def _setup_node_group(self) -> None:
-        self.node.node_tree = self.create_group()
+        self.node.node_tree = self._create_group()
 
 
 class CustomCompositorGroup(NodeGroupBuilder[CompositorNodeTree]):
@@ -545,4 +554,4 @@ class CustomCompositorGroup(NodeGroupBuilder[CompositorNodeTree]):
         return self.node.node_tree
 
     def _setup_node_group(self) -> None:
-        self.node.node_tree = self.create_group()
+        self.node.node_tree = self._create_group()

{nodebpy-520.30.1 → nodebpy-520.31.0}/src/nodebpy/export/codegen.py

@@ -1757,6 +1757,7 @@ def _factory_state_matches(node, props: dict[str, Any]) -> bool:
 # baking behavioural props (``operation``, ``mode``, …) keep requiring a
 # non-default state, as before.
 _TYPE_FACTORY_PROPS = frozenset({"data_type", "domain", "input_type", "socket_type"})
+_DATA_TYPE_PROPS = frozenset({"data_type", "input_type", "socket_type"})
 
 
 def _factory_call(
@@ -1775,7 +1776,7 @@ def _factory_call(
     from the node's value get explicit literal kwargs.
     """
     skip_key = _normalize(skip_input_id) if skip_input_id else None
-    best: tuple[_Factory, dict[str, Expr], tuple[int, int]] | None = None
+    best: tuple[_Factory, dict[str, Expr], tuple[bool, int, int]] | None = None
 
     for factory in _class_factories(cls):
         if not _factory_state_matches(node, factory.props):
@@ -1828,10 +1829,15 @@ def _factory_call(
                     continue
                 if not _eq(socket.default_value, default):
                     call_kwargs[param] = Lit(socket.default_value)
-            # Prefer the factory baking the most constants; on a tie, the one
-            # passing fewest properties through (``DeleteGeometry.edge()`` over
-            # ``DeleteGeometry.all(domain="EDGE")``).
-            rank = (len(factory.props), -len(passed))
+            # Prefer a factory baking the data type (``GetBundleItem.float(...,
+            # structure_type="SINGLE")`` over ``GetBundleItem.single(...)``),
+            # then the most constants baked, then the fewest properties passed
+            # through (``DeleteGeometry.edge()`` over ``.all(domain="EDGE")``).
+            rank = (
+                bool(_DATA_TYPE_PROPS & set(factory.props)),
+                len(factory.props),
+                -len(passed),
+            )
             if faithful and (best is None or rank > best[2]):
                 ordered = {
                     param: call_kwargs[param]