nodebpy 0.2.1__tar.gz → 0.3.0__tar.gz

{nodebpy-0.2.1 → nodebpy-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: nodebpy
-Version: 0.2.1
+Version: 0.3.0
 Summary: Build nodes in Blender with code
 Author: Brady Johnston
 Author-email: Brady Johnston <brady.johnston@me.com>
@@ -94,8 +94,8 @@ tree
 graph LR
     N0("NodeGroupInput"):::default-node
     N1("RandomValue<br/><small>(-1,-1,-1) seed:2</small>"):::converter-node
-    N2("RandomValue<br/><small>(-1,-1,-1) seed:1</small>"):::converter-node
-    N3("AlignRotationToVector<br/><small>(0,0,1)</small>"):::converter-node
+    N2("RandomValue<br/><small>(-1,-1,-1)</small>"):::converter-node
+    N3("AlignRotationToVector"):::converter-node
     N4("AxisAngleToRotation<br/><small>(0,0,1)</small>"):::converter-node
     N5("InputPosition"):::input-node
     N6("Points"):::geometry-node
@@ -109,7 +109,7 @@ graph LR
     N14("RealizeInstances"):::geometry-node
     N15("InstanceOnPoints"):::geometry-node
     N16("NodeGroupOutput"):::default-node
-    N1 -->|"Value>>Rotation"| N3
+    N1 -->|"Value>>Vector"| N3
     N4 -->|"Rotation>>Rotate By"| N8
     N3 -->|"Rotation>>Rotation"| N8
     N2 -->|"Value>>Position"| N6

{nodebpy-0.2.1 → nodebpy-0.3.0}/README.md

@@ -70,8 +70,8 @@ tree
 graph LR
     N0("NodeGroupInput"):::default-node
     N1("RandomValue<br/><small>(-1,-1,-1) seed:2</small>"):::converter-node
-    N2("RandomValue<br/><small>(-1,-1,-1) seed:1</small>"):::converter-node
-    N3("AlignRotationToVector<br/><small>(0,0,1)</small>"):::converter-node
+    N2("RandomValue<br/><small>(-1,-1,-1)</small>"):::converter-node
+    N3("AlignRotationToVector"):::converter-node
     N4("AxisAngleToRotation<br/><small>(0,0,1)</small>"):::converter-node
     N5("InputPosition"):::input-node
     N6("Points"):::geometry-node
@@ -85,7 +85,7 @@ graph LR
     N14("RealizeInstances"):::geometry-node
     N15("InstanceOnPoints"):::geometry-node
     N16("NodeGroupOutput"):::default-node
-    N1 -->|"Value>>Rotation"| N3
+    N1 -->|"Value>>Vector"| N3
     N4 -->|"Rotation>>Rotate By"| N8
     N3 -->|"Rotation>>Rotation"| N8
     N2 -->|"Value>>Position"| N6

{nodebpy-0.2.1 → nodebpy-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nodebpy"
-version = "0.2.1"
+version = "0.3.0"
 description = "Build nodes in Blender with code"
 readme = "README.md"
 authors = [

{nodebpy-0.2.1 → nodebpy-0.3.0}/src/nodebpy/builder.py

@@ -1,7 +1,11 @@
 from __future__ import annotations
 
+from ast import Return
 from typing import TYPE_CHECKING, Any, ClassVar, Literal
 
+from arrangebpy.arrange.routing import Socket
+from numpy import isin
+
 if TYPE_CHECKING:
     from .nodes import Math, VectorMath
 
@@ -21,6 +25,7 @@ from .types import (
     TYPE_INPUT_ALL,
     FloatInterfaceSubtypes,
     IntegerInterfaceSubtypes,
+    NodeBooleanMathItems,
     StringInterfaceSubtypes,
     VectorInterfaceSubtypes,
     _AttributeDomains,
@@ -52,6 +57,10 @@ def denormalize_name(attr_name: str) -> str:
     return attr_name.replace("_", " ").title()
 
 
+class SocketError(Exception):
+    """Raised when a socket operation fails."""
+
+
 class SocketContext:
     _direction: Literal["INPUT", "OUTPUT"] | None
     _active_context: SocketContext | None = None
@@ -190,6 +199,14 @@ class TreeBuilder:
         if isinstance(socket2, SocketLinker):
             socket2 = socket2.socket
 
+        if (
+            socket1.type not in SOCKET_COMPATIBILITY.get(socket2.type, ())
+            and socket2.type != "CUSTOM"
+        ):
+            raise SocketError(
+                f"Incompatible socket types, {socket1.type} and {socket2.type}"
+            )
+
         link = self.tree.links.new(socket1, socket2, handle_dynamic_sockets=True)
 
         if any(socket.is_inactive for socket in [socket1, socket2]):
@@ -224,7 +241,6 @@ class NodeBuilder:
     _from_socket: NodeSocket | None = None
     _default_input_id: str | None = None
     _default_output_id: str | None = None
-    _socket_data_types = tuple(SOCKET_COMPATIBILITY.keys())
 
     def __init__(self):
         # Get active tree from context manager
@@ -276,7 +292,6 @@ class NodeBuilder:
         counter = 0
         socket = self.node.outputs[counter]
         while not socket.is_icon_visible:
-            print(f"skipping inactive socket {socket.name}")
             counter += 1
             socket = self.node.outputs[counter]
         return socket
@@ -303,286 +318,67 @@ class NodeBuilder:
         else:
             raise TypeError(f"Unsupported type: {type(node)}")
 
-    def _find_compatible_output_socket(self, linkable: "NodeBuilder") -> NodeSocket:
-        """Find a compatible output socket from the linkable node that matches our accepted socket types."""
-        # First try the default output socket
-        default_output = linkable._default_output_socket
-        for comp in SOCKET_COMPATIBILITY[default_output.type]:
-            if comp in self._socket_data_types:
-                return default_output
-
-        # If default doesn't work, try all other output sockets
-        for output_socket in linkable.node.outputs:
-            for comp in SOCKET_COMPATIBILITY[output_socket.type]:
-                if comp in self._socket_data_types:
-                    return output_socket
-
-        # No compatible socket found
-        raise ValueError(
-            f"No compatible output socket found on {linkable.node.name} for {self.__class__.__name__}. "
-            f"Available output types: {[s.type for s in linkable.node.outputs]}, "
-            f"Accepted input types: {self._socket_data_types}"
-        )
-
-    def _find_compatible_source_socket(
-        self, source_node: "NodeBuilder", target_socket: NodeSocket
-    ) -> NodeSocket:
-        """Find a compatible output socket from source node that can link to the target input socket."""
-        target_type = target_socket.type
-        compatible_types = SOCKET_COMPATIBILITY.get(target_type, ())
-
-        # Collect all compatible sockets with their compatibility priority
-        compatible_sockets = []
-        for output_socket in source_node.node.outputs:
-            if output_socket.type in compatible_types:
-                # Priority is the index in the compatibility list (0 = highest priority)
-                priority = compatible_types.index(output_socket.type)
-                compatible_sockets.append((priority, output_socket))
-
-        if not compatible_sockets:
-            # No compatible socket found
-            raise ValueError(
-                f"No compatible output socket found on {source_node.node.name} for target socket {target_socket.name} of type {target_type}. "
-                f"Available output types: {[s.type for s in source_node.node.outputs]}, "
-                f"Compatible types: {compatible_types}"
-            )
-
-        # Sort by priority (lowest number = highest priority) and return the best match
-        compatible_sockets.sort(key=lambda x: x[0])
-        return compatible_sockets[0][1]
+    @property
+    def _available_outputs(self) -> list[NodeSocket]:
+        return [socket for socket in self.node.outputs if socket.is_icon_visible]
 
-    def _find_best_socket_pair(
-        self, target_node: "NodeBuilder"
-    ) -> tuple[NodeSocket, NodeSocket]:
-        """Find the best compatible socket pair between this node (source) and target node."""
-        # First try to connect default output to default input
-        default_output = self._default_output_socket
-        default_input = target_node._default_input_socket
-
-        # Handle zone outputs that don't have inputs yet
-        if default_input is None and hasattr(target_node, "_add_socket"):
-            # Target is a zone without inputs - create compatible socket
-            source_type = default_output.type
-            compatible_types = SOCKET_COMPATIBILITY.get(source_type, [source_type])
-            best_type = compatible_types[0] if compatible_types else source_type
-
-            # Create socket on target zone
-            default_input = target_node._add_socket(
-                name=best_type.title(), type=best_type
-            )
-            return default_output, default_input
-
-        # Check if default sockets are compatible
-        if default_input is not None:
-            output_compatibles = SOCKET_COMPATIBILITY.get(default_output.type, ())
-            if default_input.type in output_compatibles and (
-                not default_input.links or default_input.is_multi_input
-            ):
-                return default_output, default_input
-
-        # If defaults don't work, try all combinations with priority-based matching
-        best_match = None
-        best_priority = float("inf")
-
-        for output_socket in self.node.outputs:
-            output_compatibles = SOCKET_COMPATIBILITY.get(output_socket.type, ())
-            for input_socket in target_node.node.inputs:
-                # Skip if socket already has a link and isn't multi-input
-                if input_socket.links and not input_socket.is_multi_input:
-                    continue
-
-                if input_socket.type in output_compatibles:
-                    # Calculate priority as the index in the compatibility list
-                    priority = output_compatibles.index(input_socket.type)
-                    if priority < best_priority:
-                        best_priority = priority
-                        best_match = (output_socket, input_socket)
-
-        if best_match:
-            return best_match
-
-        # No compatible pair found
-        available_outputs = [s.type for s in self.node.outputs]
-        available_inputs = [
-            s.type for s in target_node.node.inputs if not s.links or s.is_multi_input
+    @property
+    def _available_inputs(self) -> list[NodeSocket]:
+        return [
+            socket
+            for socket in self.node.inputs
+            # only sockets that are available, don't have a link already (unless multi-input)
+            if not socket.is_inactive
+            and socket.is_icon_visible
+            and (not socket.links or socket.is_multi_input)
         ]
-        raise RuntimeError(
-            f"Cannot link any output from {self.node.name} to any input of {target_node.node.name}. "
-            f"Available output types: {available_outputs}, "
-            f"Available input types: {available_inputs}"
-        )
-
-    def _socket_type_from_linkable(self, linkable: LINKABLE):
-        assert linkable, "Linkable cannot be None"
-        # If it's a NodeBuilder, try to find a compatible output socket
-        if hasattr(linkable, "node") and hasattr(linkable, "_default_output_socket"):
-            compatible_socket = self._find_compatible_output_socket(linkable)
-            socket_type = compatible_socket.type
-            for comp in SOCKET_COMPATIBILITY[socket_type]:
-                if comp in self._socket_data_types:
-                    return comp if comp != "VALUE" else "FLOAT"
-
-        # Fallback to original logic for other types
-        for comp in SOCKET_COMPATIBILITY[linkable.type]:
-            if comp in self._socket_data_types:
-                return comp if comp != "VALUE" else "FLOAT"
-        raise ValueError(
-            f"Unsupported socket type for linking: {linkable}, type: {linkable.type=}"
-        )
-
-    def _add_inputs(self, *args, **kwargs) -> dict[str, LINKABLE]:
-        """Dictionary with {new_socket.name: from_linkable} for link creation"""
-        new_sockets = {}
-        items = {}
-        for arg in args:
-            if isinstance(arg, bpy.types.NodeSocket):
-                name = arg.name
-                items[name] = arg
-            else:
-                items[arg._default_output_socket.name] = arg
-        items.update(kwargs)
-        for key, value in items.items():
-            # For NodeBuilder objects, find the best compatible output socket
-            if hasattr(value, "node") and hasattr(value, "_default_output_socket"):
-                compatible_socket = self._find_compatible_output_socket(value)
-                # Create a SocketLinker to represent the specific socket we want to link from
-                # from . import SocketLinker
-                socket_linker = SocketLinker(compatible_socket)
-                type = self._socket_type_from_linkable(value)
-                socket = self._add_socket(name=key, type=type)
-                new_sockets[socket.name] = socket_linker
-            else:
-                type = self._socket_type_from_linkable(value)
-                socket = self._add_socket(name=key, type=type)
-                new_sockets[socket.name] = value
-
-        return new_sockets
 
-    def _add_socket(
-        self, name: str, type: str, default_value: Any | None = None
-    ) -> NodeSocket:
-        raise NotImplementedError
-
-    def _find_or_create_compatible_output_socket(
-        self, target_type: str
-    ) -> NodeSocket | None:
-        """Find an existing compatible output socket or create a new one if this node supports it.
-
-        Args:
-            target_type: The socket type needed for compatibility
-
-        Returns:
-            Compatible output socket if found/created, None if not possible
-        """
-        if not hasattr(self, "_add_socket"):
-            return None
+    def _best_output_socket(self, type: str) -> NodeSocket:
+        compatible = SOCKET_COMPATIBILITY.get(type, ())
+        possible = [
+            socket for socket in self._available_outputs if socket.type in compatible
+        ]
+        if possible:
+            possible.sort(key=lambda x: compatible.index(x.type))
+            return possible[0]
 
-        # Check if we already have a compatible output socket
-        if hasattr(self, "outputs"):
-            for name, socket_linker in self.outputs.items():
-                socket_compatibles = SOCKET_COMPATIBILITY.get(
-                    socket_linker.socket.type, []
-                )
-                if target_type in socket_compatibles:
-                    return socket_linker.socket
+        raise SocketError("No compatible output sockets found")
 
-        # No existing compatible socket found, try to create one
-        try:
-            # Check if this node type supports the target socket type
-            # by examining the type signature of _add_socket
-            import inspect
-
-            sig = inspect.signature(self._add_socket)
-            type_param = sig.parameters.get("type")
-
-            # If there's a type annotation that limits the allowed types, check it
-            if type_param and hasattr(type_param.annotation, "__args__"):
-                # This is a Literal type with specific allowed values
-                allowed_types = list(type_param.annotation.__args__)
-                if target_type not in allowed_types:
-                    # Try to find a compatible type that this node can create
-                    for allowed_type in allowed_types:
-                        if target_type in SOCKET_COMPATIBILITY.get(allowed_type, []):
-                            # Create the allowed type instead
-                            self._add_socket(
-                                name=allowed_type.title(), type=allowed_type
-                            )
-                            break
-                    else:
-                        # No compatible type found
-                        return None
-                else:
-                    # Target type is directly supported
-                    self._add_socket(name=target_type.title(), type=target_type)
-            else:
-                # No type restrictions, try to create the target type
-                self._add_socket(name=target_type.title(), type=target_type)
-
-            # Find the newly created output socket
-            if hasattr(self, "outputs"):
-                for name, socket_linker in self.outputs.items():
-                    socket_compatibles = SOCKET_COMPATIBILITY.get(
-                        socket_linker.socket.type, []
-                    )
-                    if target_type in socket_compatibles:
-                        return socket_linker.socket
-
-            # Fallback: try to get the socket directly from the node
-            if hasattr(self.node, "outputs"):
-                for output_socket in self.node.outputs:
-                    socket_compatibles = SOCKET_COMPATIBILITY.get(
-                        output_socket.type, []
+    @staticmethod
+    def _find_best_socket_pair(
+        source: "NodeBuilder | NodeSocket", target: "NodeBuilder | NodeSocket"
+    ) -> tuple[NodeSocket, NodeSocket]:
+        """Find the best possible compatible pair of sockets between two nodes, looking only at the
+        the currently available outputs from the source and the inputs from the target"""
+        possible_combos = []
+        if isinstance(source, NodeBuilder):
+            outputs = source._available_outputs
+        else:
+            outputs = [source]
+        if isinstance(target, NodeBuilder):
+            inputs = target._available_inputs
+        else:
+            inputs = [target]
+        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 target_type in socket_compatibles:
-                        return output_socket
-        except (NotImplementedError, AttributeError, RuntimeError):
-            # Node doesn't support dynamic socket creation or the type is not supported
-            pass
-
-        return None
-
-    def _smart_link_to(self, target_node: "NodeBuilder") -> "NodeBuilder":
-        """Smart linking that creates compatible sockets when needed.
 
-        This method checks if we have a compatible output socket for the target node's input,
-        and creates one if this node supports dynamic socket creation.
+        if possible_combos:
+            # sort by distance between compatible sockets and return the best match
+            return sorted(possible_combos, key=lambda x: x[0])[0][1]
 
-        Args:
-            target_node: The node to link to
-
-        Returns:
-            The target node (for chaining)
-        """
-        if not hasattr(target_node, "_default_input_socket"):
-            # Fall back to regular linking
-            return target_node
-
-        target_socket = target_node._default_input_socket
-        if not target_socket:
-            # Target has no input socket - can't link
-            return target_node
-
-        # Check if our default output is compatible
-        source_socket = self._default_output_socket
-        if source_socket:
-            source_compatibles = SOCKET_COMPATIBILITY.get(source_socket.type, [])
-            if target_socket.type in source_compatibles:
-                # Compatible - use normal linking
-                self.tree.link(source_socket, target_socket)
-                return target_node
-
-        # Not compatible - try to find/create a compatible output socket
-        compatible_socket = self._find_or_create_compatible_output_socket(
-            target_socket.type
+        raise SocketError(
+            f"Cannot link any output from {source.node.name} to any input of {target.node.name}. "
+            f"Available output types: {[f'{o.name}:{o.type}' for o in outputs]}, "
+            f"Available input types: {[f'{i.name}:{i.type}' for i in inputs]}"
         )
-        if compatible_socket:
-            self.tree.link(compatible_socket, target_socket)
-            return target_node
-
-        # Fall back to regular linking (may create reroute nodes)
-        if source_socket:
-            self.tree.link(source_socket, target_socket)
-        return target_node
 
     def _input_idx(self, identifier: str) -> int:
         # currently there is a Blender bug that is preventing the lookup of sockets from identifiers on some
@@ -621,28 +417,15 @@ class NodeBuilder:
     def _link(
         self, source: LINKABLE | SocketLinker | NodeSocket, target: LINKABLE
     ) -> bpy.types.NodeLink:
-        return self.tree.link(self._source_socket(source), self._target_socket(target))
-
-    def _link_to(self, target: LINKABLE) -> bpy.types.NodeLink:
-        return self.tree.link(self._default_output_socket, self._target_socket(target))
+        source_socket = self._source_socket(source)
+        target_socket = self._target_socket(target)
+        return self.tree.link(source_socket, target_socket)
 
     def _link_from(
         self,
         source: LINKABLE,
         input: LINKABLE | str,
     ):
-        # Special handling for dynamic socket nodes (zones, bake, capture attribute, etc.)
-        # These nodes have an 'outputs' property that returns a dict based on their items
-        if (
-            hasattr(source, "_add_socket")
-            and hasattr(source, "_smart_link_to")
-            and hasattr(source.__class__, "outputs")
-            and isinstance(getattr(source.__class__, "outputs"), property)
-            and not isinstance(input, str)
-        ):
-            # Use smart linking that can create compatible sockets
-            return source._smart_link_to(input)
-
         if isinstance(input, str):
             try:
                 self._link(source, self.node.inputs[input])
@@ -651,39 +434,6 @@ class NodeBuilder:
         else:
             self._link(source, input)
 
-    def _smart_link_from(
-        self,
-        source: LINKABLE,
-        input_name: str,
-    ):
-        """Smart linking that finds compatible sockets when default fails."""
-        # Get the target input socket
-        try:
-            target_socket = self.node.inputs[input_name]
-        except KeyError:
-            target_socket = self.node.inputs[self._input_idx(input_name)]
-
-        # If source is a NodeBuilder, find the best compatible output socket
-        if isinstance(source, NodeBuilder):
-            # Search for compatible output sockets - don't try default first as it might be wrong type
-            try:
-                compatible_output = self._find_compatible_source_socket(
-                    source, target_socket
-                )
-                self._link(compatible_output, target_socket)
-                return
-            except ValueError:
-                # No compatible socket found - this is an error, don't fall back
-                raise ValueError(
-                    f"Cannot link {source.node.name} to {self.node.name}.{input_name}: "
-                    f"No compatible sockets. Available output types: {[s.type for s in source.node.outputs]}, "
-                    f"Target socket type: {target_socket.type}, "
-                    f"Compatible types: {SOCKET_COMPATIBILITY.get(target_socket.type, ())}"
-                )
-        else:
-            # For other types, use original link_from behavior
-            self._link_from(source, input_name)
-
     def _set_input_default_value(self, input, value):
         """Set the default value for an input socket, handling type conversions."""
         if (
@@ -695,62 +445,28 @@ class NodeBuilder:
         else:
             input.default_value = value
 
-    def _find_best_compatible_socket(
-        self, target_node: "NodeBuilder", output_socket: NodeSocket
-    ) -> NodeSocket:
-        """Find the best compatible input socket on target node for the given output socket."""
-        output_type = output_socket.type
-        compatible_types = SOCKET_COMPATIBILITY.get(output_type, ())
-
-        # Collect all compatible input sockets with their priority
-        compatible_inputs = []
-        for input_socket in target_node.node.inputs:
-            # Skip if socket already has a link and isn't multi-input
-            if input_socket.links and not input_socket.is_multi_input:
-                continue
-
-            if input_socket.type in compatible_types:
-                # Priority is the index in the compatibility list (0 = highest priority)
-                priority = compatible_types.index(input_socket.type)
-                compatible_inputs.append((priority, input_socket))
-
-        if not compatible_inputs:
-            # No compatible socket found
-            available_types = [
-                socket.type
-                for socket in target_node.node.inputs
-                if not socket.links or socket.is_multi_input
-            ]
-            raise RuntimeError(
-                f"Cannot link {output_type} output to {target_node.node.name}. "
-                f"Compatible types: {compatible_types}, "
-                f"Available input types: {available_types}"
-            )
-
-        # Sort by priority (lowest number = highest priority) and return the best match
-        compatible_inputs.sort(key=lambda x: x[0])
-        return compatible_inputs[0][1]
-
     def _establish_links(self, **kwargs: TYPE_INPUT_ALL):
         input_ids = [input.identifier for input in self.node.inputs]
         for name, value in kwargs.items():
             if value is None:
                 continue
+            if isinstance(value, Node):
+                node = NodeBuilder()
+                node.node = value
+                value = node
 
             if value is ...:
                 # Ellipsis indicates this input should receive links from >> operator
                 # which can potentially target multiple inputs on the new node
                 if self._from_socket is not None:
-                    self._link(
-                        self._from_socket, self.node.inputs[self._input_idx(name)]
-                    )
+                    self._link_from(self._from_socket, name)
 
             elif isinstance(value, SocketLinker):
-                self._link(value, self.node.inputs[self._input_idx(name)])
-            # we can also provide just a default value for the socket to take if we aren't
-            # providing a socket to link with
-            elif isinstance(value, (NodeBuilder, NodeSocket, Node)):
-                self._smart_link_from(value, name)
+                self._link_from(value, name)
+            elif isinstance(value, NodeSocket):
+                self._link_from(value, name)
+            elif isinstance(value, NodeBuilder):
+                self._link_from(value._best_output_socket(self._input(name).type), name)
             else:
                 if name in input_ids:
                     input = self.node.inputs[input_ids.index(name)]
@@ -772,31 +488,16 @@ class NodeBuilder:
         Returns the right-hand node to enable continued chaining.
         """
         if isinstance(other, SocketLinker):
-            # Direct socket linking - use default output
-            socket_out = self._default_output_socket
-            socket_in = other.socket
-            other._from_socket = socket_out
+            source = self._default_output_socket
+            target = other.socket
+            other._from_socket = source
         else:
-            # Standard NodeBuilder linking - need to find compatible sockets
-            if other._link_target is not None:
-                # Target socket is specified
-                socket_in = self._get_input_socket_by_name(other, other._link_target)
-                socket_out = self._default_output_socket
-
-                # Try to find a better source socket if default doesn't work
-                try:
-                    socket_out = self._find_compatible_source_socket(self, socket_in)
-                except ValueError:
-                    # If no compatible socket found, use default and let the link fail with a clear error
-                    pass
-
-                other._from_socket = socket_out
-            else:
-                # No target specified - find best compatible socket pair
-                socket_out, socket_in = self._find_best_socket_pair(other)
-                other._from_socket = socket_out
+            try:
+                source, target = self._find_best_socket_pair(self, other)
+            except SocketError:
+                source, target = other._find_best_socket_pair(self, other)
 
-        self.tree.link(socket_out, socket_in)
+        self.tree.link(source, target)
         return other
 
     def _get_input_socket_by_name(self, node: "NodeBuilder", name: str) -> NodeSocket:
@@ -819,14 +520,14 @@ class NodeBuilder:
             else (other, self._default_output_socket)
         )
 
-        # Determine if either operand is a vector type
-        self_is_vector = self._default_output_socket.type == "VECTOR"
-        other_is_vector = False
-        if isinstance(other, NodeBuilder):
-            other_is_vector = other._default_output_socket.type == "VECTOR"
+        component_is_vector = False
+        for value in values:
+            if getattr(value, "type", None) == "VECTOR":
+                component_is_vector = True
+                break
 
         # Use VectorMath if either operand is a vector
-        if self_is_vector or other_is_vector:
+        if component_is_vector:
             if operation == "multiply":
                 # Handle special cases for vector multiplication where we might scale instead
                 # of using the multiply method
@@ -838,7 +539,7 @@ class NodeBuilder:
                     return VectorMath.multiply(*values)
                 else:
                     raise TypeError(
-                        f"Unsupported type for {operation} with VECTOR socket: {type(other)}"
+                        f"Unsupported type for {operation} with VECTOR socket: {type(other)}, {other=}"
                     )
             else:
                 vector_method = getattr(VectorMath, operation)
@@ -858,11 +559,10 @@ class NodeBuilder:
                     raise TypeError(
                         f"Unsupported type for {operation} with VECTOR operand: {type(other)}"
                     )
-        else:
-            # Both operands are scalar types, use regular Math
+        else:  # Both operands are scalar types, use regular Math
             from .nodes.converter import IntegerMath, Math
 
-            if isinstance(other, int):
+            if isinstance(other, int) and self._default_output_socket.type == "INT":
                 return getattr(IntegerMath, operation)(*values)
             else:
                 return getattr(Math, operation)(*values)
@@ -892,6 +592,78 @@ class NodeBuilder:
         return self._apply_math_operation(other, "subtract", reverse=True)
 
 
+class DynamicInputsMixin:
+    _socket_data_types: tuple[str]
+    _type_map: dict[str, str] = {}
+
+    def _match_compatible_data(self, *sockets: NodeSocket) -> tuple[NodeSocket, str]:
+        possible = []
+        for socket in sockets:
+            compatible = SOCKET_COMPATIBILITY.get(socket.type, ())
+            for type in self._socket_data_types:
+                if type in compatible:
+                    possible.append((socket, type, compatible.index(type)))
+
+        if len(possible) > 0:
+            possible.sort(key=lambda x: x[2])
+            best_value = possible[0]
+            return best_value[:2]
+
+        raise SocketError("No compatible socket found")
+
+    def _find_best_socket_pair(
+        self, source: NodeBuilder, target: NodeBuilder
+    ) -> tuple[NodeSocket, NodeSocket] | None:
+        try:
+            return super()._find_best_socket_pair(source, target)
+        except SocketError:
+            if target == self:
+                target_name, source_socket = list(target._add_inputs(source).items())[0]
+                return (source_socket, target.inputs[target_name].socket)
+            else:
+                target_name, source_socket = list(
+                    source._add_inputs(*target.node.inputs).items()
+                )[0]
+                return (
+                    source.outputs[target_name].socket,
+                    target.inputs[target_name].socket,
+                )
+
+            for target_name, source_socket in new_sockets.items():
+                target_socket = target.inputs[target_name].socket
+                return (source_socket, target_socket)
+
+    # def _best_output_socket(self, type: str) -> NodeSocket:
+    #     # compatible = SOCKET_COMPATIBILITY.get(type, ())
+    #     # possible = [
+    #     #     socket for socket in self._available_outputs if socket.type in compatible
+    #     # ]
+    #     # if possible:
+    #     #     return sorted(possible, key=lambda x: compatible.index(x.type))[0]
+
+    #     raise SocketError("No compatible output sockets found")
+
+    def _add_inputs(self, *args, **kwargs) -> dict[str, LINKABLE]:
+        """Dictionary with {new_socket.name: from_linkable} for link creation"""
+        new_sockets = {}
+        items = {}
+        for arg in args:
+            if isinstance(arg, bpy.types.NodeSocket):
+                name = arg.name
+                items[name] = arg
+            else:
+                items[arg._default_output_socket.name] = arg
+        items.update(kwargs)
+        for key, source in items.items():
+            socket_source, type = self._match_compatible_data(*source.node.outputs)
+            if type in self._type_map:
+                type = self._type_map[type]
+            socket = self._add_socket(name=key, type=type)
+            new_sockets[socket.name] = socket_source
+
+        return new_sockets
+
+
 class SocketLinker(NodeBuilder):
     def __init__(self, socket: NodeSocket):
         assert socket.node is not None
@@ -900,6 +672,10 @@ class SocketLinker(NodeBuilder):
         self._default_output_id = socket.identifier
         self._tree = TreeBuilder(socket.node.id_data)  # type: ignore
 
+    @property
+    def _available_outputs(self) -> list[NodeSocket]:
+        return [self.socket]
+
     @property
     def type(self) -> SOCKET_TYPES:
         return self.socket.type  # type: ignore

{nodebpy-0.2.1 → nodebpy-0.3.0}/src/nodebpy/nodes/manual.py

@@ -2,7 +2,13 @@ from typing import Any, Literal
 
 import bpy
 
-from ..builder import NodeBuilder, NodeSocket, SocketLinker
+from ..builder import (
+    DynamicInputsMixin,
+    NodeBuilder,
+    NodeSocket,
+    SocketError,
+    SocketLinker,
+)
 from ..types import (
     LINKABLE,
     SOCKET_TYPES,
@@ -77,7 +83,7 @@ __all__ = (
 )
 
 
-class Bake(NodeBuilder):
+class Bake(NodeBuilder, DynamicInputsMixin):
     """Cache the incoming data so that it can be used without recomputation
 
     TODO: properly handle Animation / Still bake opations and ability to bake to a file
@@ -171,12 +177,15 @@ class Value(NodeBuilder):
         return self._output("Value")
 
 
-class FormatString(NodeBuilder):
+class FormatString(NodeBuilder, DynamicInputsMixin):
     """Insert values into a string using a Python and path template compatible formatting syntax"""
 
     _bl_idname = "FunctionNodeFormatString"
     node: bpy.types.FunctionNodeFormatString
     _socket_data_types = ("VALUE", "INT", "STRING")
+    _type_map = {
+        "VALUE": "FLOAT",
+    }
 
     def __init__(
         self,
@@ -396,7 +405,10 @@ class JoinGeometry(NodeBuilder):
     def __init__(self, *args: LINKABLE):
         super().__init__()
         for source in reversed(args):
-            self._link_from(source, self)
+            try:
+                self._link(*self._find_best_socket_pair(source, self))
+            except SocketError:
+                self._link(*source._find_best_socket_pair(source, self))
 
     @property
     def i_geometry(self) -> SocketLinker:
@@ -769,11 +781,27 @@ def _domain_capture_attribute(domain: _AttributeDomains):
     return method
 
 
-class CaptureAttribute(NodeBuilder):
+class CaptureAttribute(NodeBuilder, DynamicInputsMixin):
     """Store the result of a field on a geometry and output the data as a node socket. Allows remembering or interpolating data as the geometry changes, such as positions before deformation"""
 
     _bl_idname = "GeometryNodeCaptureAttribute"
     node: bpy.types.GeometryNodeCaptureAttribute
+    _socket_data_types = (
+        "VALUE",
+        "INT",
+        "BOOLEAN",
+        "VECTOR",
+        "RGBA",
+        "ROTATION",
+        "MATRIX",
+    )
+    _type_map = {
+        "VALUE": "FLOAT",
+        # "VECTOR": "FLOAT_VECTOR",
+        "RGBA": "FLOAT_COLOR",
+        "ROTATION": "QUATERNION",
+        "MATRIX": "FLOAT4X4",
+    }
     point = _domain_capture_attribute("POINT")
     edge = _domain_capture_attribute("EDGE")
     face = _domain_capture_attribute("FACE")
@@ -851,7 +879,7 @@ class CaptureAttribute(NodeBuilder):
         self.node.domain = value
 
 
-class FieldToGrid(NodeBuilder):
+class FieldToGrid(DynamicInputsMixin, NodeBuilder):
     """Create new grids by evaluating new values on an existing volume grid topology
 
     New socket items for field evaluation are first created from *args then **kwargs to give specific names to the items.
@@ -873,7 +901,8 @@ class FieldToGrid(NodeBuilder):
 
     _bl_idname = "GeometryNodeFieldToGrid"
     node: bpy.types.GeometryNodeFieldToGrid
-    _socket_data_types = ("FLOAT", "VALUE", "INT", "VECTOR", "BOOLEAN")
+    _socket_data_types = ("VALUE", "INT", "VECTOR", "BOOLEAN")
+    _type_map = {"VALUE": "FLOAT"}
     _default_input_id = "Topology"
 
     def __init__(
@@ -988,7 +1017,7 @@ class SDFGridBoolean(NodeBuilder):
         for arg in args:
             if arg is None:
                 continue
-            node._link_from(arg, "Grid 2")
+            node._link_from(*node._find_best_socket_pair(arg, node._input("Grid 2")))
         return node
 
     @classmethod
@@ -1000,7 +1029,7 @@ class SDFGridBoolean(NodeBuilder):
         for arg in args:
             if arg is None:
                 continue
-            node._link_from(arg, "Grid 2")
+            node._link_from(*node._find_best_socket_pair(arg, node._input("Grid 2")))
         return node
 
     @classmethod
@@ -1011,11 +1040,11 @@ class SDFGridBoolean(NodeBuilder):
     ) -> "SDFGridBoolean":
         """Create SDF Grid Boolean with operation 'Difference'."""
         node = cls(operation="DIFFERENCE")
-        node._link_from(grid_1, "Grid 1")
+        node._link_from(*node._find_best_socket_pair(grid_1, node._input("Grid 1")))
         for arg in args:
             if arg is None:
                 continue
-            node._link_from(arg, "Grid 2")
+            node._link_from(*node._find_best_socket_pair(arg, node._input("Grid 2")))
         return node
 
     @property

{nodebpy-0.2.1 → nodebpy-0.3.0}/src/nodebpy/nodes/zone.py

@@ -2,9 +2,8 @@ from abc import ABC, abstractmethod
 from typing import Literal
 
 import bpy
-from bpy.types import NodeSocket
 
-from nodebpy.builder import NodeBuilder, SocketLinker
+from nodebpy.builder import DynamicInputsMixin, NodeBuilder, SocketLinker
 
 from ..types import (
     LINKABLE,
@@ -16,7 +15,7 @@ from ..types import (
 )
 
 
-class BaseZone(NodeBuilder, ABC):
+class BaseZone(DynamicInputsMixin, NodeBuilder, ABC):
     _items_attribute: Literal["state_items", "repeat_items"]
 
     @property
@@ -81,30 +80,6 @@ class BaseZoneInput(BaseZone, NodeBuilder, ABC):
         item = self.items.new(type, name)
         return self.inputs[item.name]
 
-    def __rshift__(self, other):
-        """Custom zone input linking that creates sockets as needed"""
-        # Check if target is a zone output without inputs
-        if (
-            hasattr(other, "_default_input_socket")
-            and other._default_input_socket is None
-        ):
-            # Target zone needs a socket - create one based on our output
-            from ..builder import SOCKET_COMPATIBILITY
-
-            source_socket = self._default_output_socket
-            source_type = source_socket.type
-
-            compatible_types = SOCKET_COMPATIBILITY.get(source_type, [source_type])
-            best_type = compatible_types[0] if compatible_types else source_type
-
-            # Create socket on target zone
-            target_socket = other._add_socket(name=best_type.title(), type=best_type)
-            self.tree.link(source_socket, target_socket)
-            return other
-        else:
-            # Use the general smart linking approach
-            return self._smart_link_to(other)
-
 
 class BaseZoneOutput(BaseZone, NodeBuilder, ABC):
     """Base class for zone output nodes"""
@@ -122,69 +97,22 @@ class BaseZoneOutput(BaseZone, NodeBuilder, ABC):
         item = self.items.new(type, name)
         return self.node.inputs[item.name]
 
-    def __rshift__(self, other):
-        """Custom zone output linking that creates sockets as needed"""
-        from ..builder import SOCKET_COMPATIBILITY
-
-        # Get the source socket type
-        source_socket = self._default_output_socket
-        source_type = source_socket.type
-
-        # Check if target has compatible inputs
-        if hasattr(other, "_default_input_socket") and other._default_input_socket:
-            # Normal linking
-            return super().__rshift__(other)
-        elif hasattr(other, "_add_socket"):
-            # Target is also a zone - create compatible socket
-            compatible_types = SOCKET_COMPATIBILITY.get(source_type, [source_type])
-            best_type = compatible_types[0] if compatible_types else source_type
-
-            # Create socket on target zone
-            target_socket = other._add_socket(name=best_type.title(), type=best_type)
-            self.tree.link(source_socket, target_socket)
-            return other
-        else:
-            # Normal NodeBuilder
-            return super().__rshift__(other)
-
-    @property
-    def _default_input_socket(self) -> NodeSocket:
-        """Get default input socket, avoiding skip-type sockets"""
-        inputs = list(self.inputs.values())
-        if inputs:
-            return inputs[0].socket
-        else:
-            # No socket exists - this should be handled by zone-specific __rshift__ logic
-            # Return None to signal that a socket needs to be created
-            return None
-
-
-class SimulationZone:
-    def __init__(self, *args: LINKABLE, **kwargs: LINKABLE):
-        self.input = SimulationInput()
-        self.output = SimulationOutput()
-        self.input.node.pair_with_output(self.output.node)
-
-        self.output.node.state_items.clear()
-        socket_lookup = self.output._add_inputs(*args, **kwargs)
-        for name, source in socket_lookup.items():
-            self.input._link_from(source, name)
-
-    def delta_time(self) -> SocketLinker:
-        return self.input.o_delta_time
-
-    def __getitem__(self, index: int):
-        match index:
-            case 0:
-                return self.input
-            case 1:
-                return self.output
-            case _:
-                raise IndexError("SimulationZone has only two items")
-
 
 class BaseSimulationZone(BaseZone):
     _items_attribute = "state_items"
+    _socket_data_types = (
+        "VALUE",
+        "INT",
+        "BOOLEAN",
+        "VECTOR",
+        "RGBA",
+        "ROTATION",
+        "MATRIX",
+        "STRING",
+        "GEOMETRY",
+        "BUNDLE",
+    )
+    _type_map = {"VALUE": "FLOAT"}
 
     @property
     def items(self) -> bpy.types.NodeGeometrySimulationOutputItems:
@@ -215,39 +143,49 @@ class SimulationOutput(BaseSimulationZone, BaseZoneOutput):
         return self._input("Skip")
 
 
-class RepeatZone:
-    """Wrapper that supports both direct unpacking and iteration"""
-
-    def __init__(
-        self, iterations: TYPE_INPUT_INT = 1, *args: LINKABLE, **kwargs: LINKABLE
-    ):
-        self.input = RepeatInput(iterations)
-        self.output = RepeatOutput()
+class SimulationZone:
+    def __init__(self, *args: LINKABLE, **kwargs: LINKABLE):
+        self.input = SimulationInput()
+        self.output = SimulationOutput()
         self.input.node.pair_with_output(self.output.node)
 
-        self.output.node.repeat_items.clear()
-        self.input._establish_links(**self.input._add_inputs(*args, **kwargs))
-
-    @property
-    def i(self) -> SocketLinker:
-        """Input socket: Skip simluation frame"""
-        return self.input.o_iteration
+        self.output.node.state_items.clear()
+        socket_lookup = self.output._add_inputs(*args, **kwargs)
+        for name, source in socket_lookup.items():
+            self.input._link_from(source, name)
 
-    def __iter__(self):
-        """Support for loop: for i, input, output in RepeatZone(...)"""
-        self._index = 0
-        return self
+    def delta_time(self) -> SocketLinker:
+        return self.input.o_delta_time
 
-    def __next__(self):
-        """Support for iteration: next(RepeatZone)"""
-        if self._index > 0:
-            raise StopIteration
-        self._index += 1
-        return self.i, self.input, self.output
+    def __getitem__(self, index: int):
+        match index:
+            case 0:
+                return self.input
+            case 1:
+                return self.output
+            case _:
+                raise IndexError("SimulationZone has only two items")
 
 
 class BaseRepeatZone(BaseZone):
     _items_attribute = "repeat_items"
+    _socket_data_types = (
+        "FLOAT",
+        "INT",
+        "BOOLEAN",
+        "VECTOR",
+        "RGBA",
+        "ROTATION",
+        "MATRIX",
+        "STRING",
+        "OBJECT",
+        "IMAGE",
+        "GEOMETRY",
+        "COLLECTION",
+        "MATERIAL",
+        "BUNDLE",
+        "CLOSURE",
+    )
 
     @property
     def items(self) -> bpy.types.NodeGeometryRepeatOutputItems:
@@ -284,6 +222,37 @@ class RepeatOutput(BaseRepeatZone, BaseZoneOutput):
     node: bpy.types.GeometryNodeRepeatOutput
 
 
+class RepeatZone:
+    """Wrapper that supports both direct unpacking and iteration"""
+
+    def __init__(
+        self, iterations: TYPE_INPUT_INT = 1, *args: LINKABLE, **kwargs: LINKABLE
+    ):
+        self.input = RepeatInput(iterations)
+        self.output = RepeatOutput()
+        self.input.node.pair_with_output(self.output.node)
+
+        self.output.node.repeat_items.clear()
+        self.input._establish_links(**self.input._add_inputs(*args, **kwargs))
+
+    @property
+    def i(self) -> SocketLinker:
+        """Input socket: Skip simluation frame"""
+        return self.input.o_iteration
+
+    def __iter__(self):
+        """Support for loop: for i, input, output in RepeatZone(...)"""
+        self._index = 0
+        return self
+
+    def __next__(self):
+        """Support for iteration: next(RepeatZone)"""
+        if self._index > 0:
+            raise StopIteration
+        self._index += 1
+        return self.i, self.input, self.output
+
+
 class ForEachGeometryElementInput(NodeBuilder):
     """For Each Geometry Element Input node"""
 

{nodebpy-0.2.1 → nodebpy-0.3.0}/src/nodebpy/types.py

@@ -280,7 +280,7 @@ SOCKET_TYPES = Literal[
     "CLOSURE",
 ]
 
-SOCKET_COMPATIBILITY = {
+SOCKET_COMPATIBILITY: dict[str, tuple[str]] = {
     "VALUE": (
         "VALUE",
         "VECTOR",