nodebpy 0.2.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

nodebpy/builder.py

@@ -1,9 +1,13 @@
 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.converter import Math, VectorMath
+    from .nodes import Math, VectorMath
 
 import arrangebpy
 import bpy
@@ -14,13 +18,14 @@ from bpy.types import (
     NodeSocket,
 )
 
-from .nodes.types import (
+from .types import (
     LINKABLE,
     SOCKET_COMPATIBILITY,
     SOCKET_TYPES,
     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
@@ -117,12 +126,10 @@ class TreeBuilder:
     just_added: "Node | None" = None
 
     def __init__(
-        self, tree: "GeometryNodeTree | str | None" = None, arrange: bool = True
+        self, tree: GeometryNodeTree | str = "Geometry Nodes", arrange: bool = True
     ):
         if isinstance(tree, str):
             self.tree = bpy.data.node_groups.new(tree, "GeometryNodeTree")
-        elif tree is None:
-            self.tree = bpy.data.node_groups.new("GeometryNodeTree", "GeometryNodeTree")
         else:
             assert isinstance(tree, GeometryNodeTree)
             self.tree = tree
@@ -192,17 +199,27 @@ 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]):
+            assert socket1.node
+            assert socket2.node
             # the warning message should report which sockets from which nodes were linked and which were innactive
             for socket in [socket1, socket2]:
                 # we want to be loud about it if we end up linking an inactive socket to a node that is not a switch
-                if socket.is_inactive and socket.node.bl_idname not in (
+                if socket.is_inactive and socket.node.bl_idname not in (  # type: ignore
                     "GeometryNodeIndexSwitch",
                     "GeometryNodeMenuSwitch",
                 ):
-                    message = f"Socket {socket.name} from node {socket.node.name} is inactive."
+                    message = f"Socket {socket.name} from node {socket.node.name} is inactive."  # type: ignore
                     message += f" It is linked to socket {socket2.name} from node {socket2.node.name}."
                     message += " This link will be created by Blender but ignored when evaluated."
                     message += f"Socket type: {socket.bl_idname}"
@@ -211,21 +228,19 @@ class TreeBuilder:
         return link
 
     def add(self, name: str) -> Node:
-        self.just_added = self.tree.nodes.new(name)  # type: ignore
-        assert self.just_added is not None
-        return self.just_added
+        return self.tree.nodes.new(name)
 
 
 class NodeBuilder:
     """Base class for all geometry node wrappers."""
 
     node: Any
+    _bl_idname: str
     _tree: "TreeBuilder"
     _link_target: str | None = None
     _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
@@ -241,7 +256,7 @@ class NodeBuilder:
         self._tree = tree
         self._link_target = None
         if self.__class__.name is not None:
-            self.node = self._tree.add(self.__class__.name)
+            self.node = self._tree.add(self.__class__._bl_idname)
         else:
             raise ValueError(
                 f"Class {self.__class__.__name__} must define a 'name' attribute"
@@ -273,7 +288,13 @@ class NodeBuilder:
     def _default_output_socket(self) -> NodeSocket:
         if self._default_output_id is not None:
             return self.node.outputs[self._output_idx(self._default_output_id)]
-        return self.node.outputs[0]
+
+        counter = 0
+        socket = self.node.outputs[counter]
+        while not socket.is_icon_visible:
+            counter += 1
+            socket = self.node.outputs[counter]
+        return socket
 
     def _source_socket(self, node: LINKABLE | SocketLinker | NodeSocket) -> NodeSocket:
         assert node
@@ -297,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.
+        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]
 
-        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.
-
-        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
@@ -615,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])
@@ -645,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 (
@@ -689,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)]
@@ -766,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:
@@ -805,7 +512,7 @@ class NodeBuilder:
         self, other: Any, operation: str, reverse: bool = False
     ) -> "VectorMath | Math":
         """Apply a math operation with appropriate Math/VectorMath node."""
-        from .nodes.converter import VectorMath
+        from .nodes import VectorMath
 
         values = (
             (self._default_output_socket, other)
@@ -813,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
@@ -832,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)
@@ -852,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)
@@ -886,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
@@ -894,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