nodebpy 0.11.1__tar.gz → 0.13.0__tar.gz

{nodebpy-0.11.1 → nodebpy-0.13.0}/PKG-INFO

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

{nodebpy-0.11.1 → nodebpy-0.13.0}/pyproject.toml

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

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/__init__.py

@@ -1,5 +1,7 @@
-from . import nodes, diagram, sockets
-from .builder import TreeBuilder, NodeGroupBuilder
+from . import diagram, nodes, sockets
+from .builder import (
+    TreeBuilder,
+)
 from .nodes import compositor, geometry, shader
 
 __all__ = [
@@ -10,5 +12,4 @@ __all__ = [
     "sockets",
     "diagram",
     "TreeBuilder",
-    "NodeGroupBuilder",
 ]

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/builder/__init__.py

@@ -27,7 +27,14 @@ from .interface import (
     SocketVector,
 )
 from .mixins import LinkingMixin, OperatorMixin
-from .node import BaseNode, DynamicInputsMixin, NodeGroupBuilder
+from .node import (
+    BaseNode,
+    CustomCompositorGroup,
+    CustomGeometryGroup,
+    CustomShaderGroup,
+    DynamicInputsMixin,
+    NodeGroupBuilder,
+)
 from .socket import (
     BooleanSocket,
     BundleSocket,
@@ -82,6 +89,12 @@ __all__ = [
     "DynamicInputsMixin",
     # Node groups
     "NodeGroupBuilder",
+    "CustomCompositorGroup",
+    "CustomGeometryGroup",
+    "CustomShaderGroup",
+    "GeometryNodeGroup",
+    "ShaderNodeGroup",
+    "CompositorNodeGroup",
     # Type-specific socket classes (runtime)
     "FloatSocket",
     "VectorSocket",

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/builder/_utils.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import Any
+from typing import Any, Protocol, runtime_checkable
 
 import bpy
 from bpy.types import NodeSocket
@@ -67,15 +67,24 @@ def _resolve_promotion(
 
     if other_prec > self_prec:
         # Other side is dominant — swap so the linker wraps the vector/higher socket
-        other_socket = other._default_output_socket
+        if isinstance(other, NodeSocket):
+            other_socket = other
+        else:
+            other_socket = other._default_output_socket
         return other_socket, self_socket, not reverse
 
     return self_socket, other, reverse
 
 
-class _NodeLike:
-    """Marker base for objects that wrap a Blender node (have .node, .inputs, .outputs)."""
+@runtime_checkable
+class _NodeLike(Protocol):
+    """Protocol for objects that wrap a Blender node and expose an ``outputs`` accessor."""
 
+    outputs: Any  # SocketAccessor at runtime; typed as Any to avoid circular import
 
-class _SocketLike:
-    """Marker base for objects that wrap a single Blender NodeSocket (have .socket)."""
+
+@runtime_checkable
+class _SocketLike(Protocol):
+    """Protocol for objects that wrap a single Blender NodeSocket and expose ``.socket``."""
+
+    socket: NodeSocket

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/builder/accessor.py

@@ -28,7 +28,7 @@ class SocketAccessor:
 
     def __init__(
         self,
-        collection: bpy.types.NodeInputs | bpy.types.NodeOutputs,
+        collection: bpy.types.NodeInputs | bpy.types.NodeOutputs | list[NodeSocket],
         direction: Literal["input", "output"],
     ):
         self._direction = direction

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/builder/mixins.py

@@ -100,9 +100,12 @@ class OperatorMixin:
         )
 
     def _apply_compare_operation(self, other: Any, operation: str) -> "Math":
-        return _get_socket_linker(self._default_output_socket)._dispatch_compare(  # type: ignore[attr-defined]
-            other, operation
+        socket, other, _ = _resolve_promotion(
+            self._default_output_socket,  # type: ignore[attr-defined]
+            other,
+            False,
         )
+        return _get_socket_linker(socket)._dispatch_compare(other, operation)
 
     def __lt__(self, other: Any) -> "Compare":
         return self._apply_compare_operation(other, "less_than")
@@ -236,6 +239,11 @@ class LinkingMixin:
         else:
             inputs = [target]
 
+        # NodeReroute adapts its type to whatever is linked — skip type matching
+        if getattr(getattr(target, "node", None), "bl_idname", None) == "NodeReroute":
+            if outputs and inputs:
+                return inputs[0], outputs[0]
+
         for output in outputs:
             compat_sockets = SOCKET_COMPATIBILITY.get(output.type, ())
             for input in inputs:

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/builder/node.py

@@ -1,19 +1,47 @@
 from __future__ import annotations
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Iterable, Literal, Self
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Generic,
+    Iterable,
+    Literal,
+    Protocol,
+    Self,
+    TypeVar,
+    cast,
+)
 
 import bpy
-from bpy.types import Node, NodeSocket
-
-from ..types import SOCKET_COMPATIBILITY, SOCKET_TYPES, InputAny, InputLinkable
+from bpy.types import (
+    CompositorNodeGroup,
+    CompositorNodeTree,
+    GeometryNodeGroup,
+    GeometryNodeTree,
+    Node,
+    NodeSocket,
+    ShaderNodeGroup,
+    ShaderNodeTree,
+)
+
+from ..types import SOCKET_COMPATIBILITY, SOCKET_TYPES, InputAny
 from ._utils import SocketError, _NodeLike, _SocketLike
 from .accessor import SocketAccessor
 from .mixins import LinkingMixin, OperatorMixin
 from .tree import TreeBuilder
 
+_T = TypeVar("_T", bound=bpy.types.NodeTree)
+
 if TYPE_CHECKING:
-    pass
+
+    class _DynamicTarget(Protocol):
+        """Structural type for a node that supports dynamic socket addition."""
+
+        def _add_inputs(self, *args: Any, **kwargs: Any) -> dict[str, NodeSocket]: ...
+
+        @property
+        def inputs(self) -> SocketAccessor: ...
 
 
 class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
@@ -25,7 +53,7 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
     _default_output_id: str | None = None
     _placeholder_inputs: list[str]
 
-    def __init__(self, node: bpy.types.Node | None = None):
+    def __init__(self, node: Node | None = None):
         tree = (
             TreeBuilder._tree_contexts[-1] if len(TreeBuilder._tree_contexts) else None
         )
@@ -72,7 +100,7 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
         return socket
 
     @classmethod
-    def _from_node(cls, node: bpy.types.Node) -> Self:
+    def _from_node(cls, node: Node) -> Self:
         builder = cls()
         builder.tree.nodes.remove(builder.node)
         builder.node = node
@@ -86,7 +114,9 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
                     assert link.to_node
                     if link.to_node.bl_idname == cls._bl_idname:
                         return cls._from_node(link.to_node)
-            return cls(socket)
+            node = cls()
+            node.tree.link(socket, node.inputs._best_match(socket.type))
+            return node
         else:
             if socket.links:
                 for link in socket.links:
@@ -98,8 +128,9 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
             node >> socket
             return node
 
-    def _set_input_default_value(self, input, value):
+    def _set_input_default_value(self, input: NodeSocket, value: Any) -> None:
         """Set the default value for an input socket, handling type conversions."""
+        assert hasattr(input, "default_value")
         if (
             hasattr(input, "type")
             and input.type == "VECTOR"
@@ -115,7 +146,7 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
             if value is None or (
                 "GridPrune" in self._bl_idname
                 and name == "Threshold"
-                and self.node.data_type == "BOOLEAN"
+                and getattr(self.node, "data_type", None) == "BOOLEAN"
             ):
                 continue
             if isinstance(value, Node):
@@ -128,7 +159,7 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
                 continue
 
             elif isinstance(value, _SocketLike):
-                self._link_from(value, name)
+                self._link_from(value.socket, name)
             elif isinstance(value, NodeSocket):
                 self._link_from(value, name)
             elif isinstance(value, _NodeLike):
@@ -165,7 +196,7 @@ class BaseNode(_NodeLike, OperatorMixin, LinkingMixin):
         return SocketAccessor(self.node.inputs, "input")
 
 
-class DynamicInputsMixin:
+class DynamicInputsMixin(ABC):
     _socket_data_types: tuple[str, ...]
     _type_map: dict[str, str] = {}
 
@@ -192,10 +223,14 @@ class DynamicInputsMixin:
         try:
             return super()._find_best_socket_pair(source, target)  # type: ignore
         except SocketError:
-            target_name, source_socket = list(target._add_inputs(source).items())[0]
-            return (source_socket, target.inputs[target_name].socket)
+            dyn = cast("_DynamicTarget", target)
+            target_name, source_socket = list(dyn._add_inputs(source).items())[0]
+            return (source_socket, dyn.inputs[target_name].socket)
+
+    @abstractmethod
+    def _add_socket(self, name: str, *args: Any, **kwargs: Any) -> NodeSocket: ...
 
-    def _add_inputs(self, *args, **kwargs) -> dict[str, InputLinkable]:
+    def _add_inputs(self, *args, **kwargs) -> dict[str, NodeSocket]:
         """Dictionary with {new_socket.name: from_linkable} for link creation"""
         new_sockets = {}
         items = {}
@@ -212,14 +247,15 @@ class DynamicInputsMixin:
         return new_sockets
 
 
-class NodeGroupBuilder(BaseNode, ABC):
+class NodeGroupBuilder(BaseNode, ABC, Generic[_T]):
     """Base class for custom node groups.
 
     Subclasses implement :meth:`_build_group` with the node-graph logic.
+    Subclass one of the editor-specific variants: :class:`GeometryNodeGroup`,
+    :class:`ShaderNodeGroup`, or :class:`CompositorNodeGroup`.
     """
 
     _name: str
-    _bl_idname = "GeometryNodeGroup"
     _warning_propagation: Literal["ALL", "ERRORS_AND_WARNINGS", "ERRORS", "NONE"] = (
         "ALL"
     )
@@ -234,27 +270,113 @@ class NodeGroupBuilder(BaseNode, ABC):
         "TEXTURE",
         "VECTOR",
     ] = "NONE"
-    node: bpy.types.GeometryNodeGroup
 
     def __init__(self, **kwargs):
         super().__init__()
-        self.node.node_tree = self._get_or_create_group()
+        self._setup_node_group()
         self.node.show_options = False
-        self.node.warning_propagation = self._warning_propagation
         self._establish_links(**kwargs)
 
-    def _get_or_create_group(self) -> bpy.types.GeometryNodeTree:
-        name = self._name
-        if name in bpy.data.node_groups:
-            return bpy.data.node_groups[name]
+    @property
+    @abstractmethod
+    def node_tree(self) -> _T:
+        """The internal node tree for this group node."""
+        ...
 
-        with TreeBuilder(name) as tree:
-            self._build_group(tree)
-            tree.tree.color_tag = self._color_tag
+    @abstractmethod
+    def _setup_node_group(self) -> None:
+        """Set ``self.node.node_tree`` and any node-type-specific properties.
 
-        return tree.tree
+        Called by ``__init__`` after the node is created but before links are
+        established. Concrete subclasses have a narrowed ``self.node`` type,
+        so the ``node_tree`` assignment is type-safe here rather than in the
+        base class where ``self.node`` is only ``bpy.types.Node``.
+        """
+        ...
 
-    @classmethod
     @abstractmethod
-    def _build_group(cls, tree: TreeBuilder) -> None:
-        """Code that builds the node group internals and interface"""
+    def _build_group(self, tree: TreeBuilder) -> None:
+        """Build the node group internals and interface."""
+
+    def _get_or_create_tree(self) -> _T:
+        existing = bpy.data.node_groups[self._name]
+        if existing.bl_idname == self.tree.tree.bl_idname:
+            return cast(_T, existing)
+        raise TypeError(
+            f"Node group '{self._name}' already exists as "
+            f"{type(existing).__name__}, not {self._bl_idname}. "
+            f"Use a unique _name for this group."
+        )
+
+
+class CustomGeometryGroup(NodeGroupBuilder[GeometryNodeTree]):
+    """Node group in a Geometry Nodes tree."""
+
+    _bl_idname = "GeometryNodeGroup"
+    node: GeometryNodeGroup
+
+    @property
+    def node_tree(self) -> GeometryNodeTree:
+        assert self.node.node_tree is not None
+        return self.node.node_tree
+
+    def _setup_node_group(self) -> None:
+        self.node.node_tree = self._get_or_create_group()
+        self.node.warning_propagation = self._warning_propagation
+
+    def _get_or_create_group(self) -> GeometryNodeTree:
+        try:
+            return self._get_or_create_tree()
+        except KeyError:
+            with TreeBuilder.geometry(self._name) as tree:
+                self._build_group(tree)
+            tree.tree.color_tag = self._color_tag
+            return tree.tree
+
+
+class CustomShaderGroup(NodeGroupBuilder[ShaderNodeTree]):
+    """Node group in a Shader (Material) node tree."""
+
+    _bl_idname = "ShaderNodeGroup"
+    node: ShaderNodeGroup
+
+    @property
+    def node_tree(self) -> ShaderNodeTree:
+        assert self.node.node_tree is not None
+        return self.node.node_tree
+
+    def _setup_node_group(self) -> None:
+        self.node.node_tree = self._get_or_create_group()
+
+    def _get_or_create_group(self) -> ShaderNodeTree:
+        try:
+            return self._get_or_create_tree()
+        except KeyError:
+            with TreeBuilder.shader(self._name) as tree:
+                self._build_group(tree)
+            tree.tree.color_tag = self._color_tag
+            return tree.tree
+
+
+class CustomCompositorGroup(NodeGroupBuilder[CompositorNodeTree]):
+    """Node group in a Compositor node tree."""
+
+    _bl_idname = "CompositorNodeGroup"
+    node: CompositorNodeGroup
+
+    @property
+    def node_tree(self) -> CompositorNodeTree:
+        assert self.node.node_tree is not None
+        return self.node.node_tree
+
+    def _setup_node_group(self) -> None:
+        self.node.node_tree = self._get_or_create_group()
+
+    def _get_or_create_group(self) -> CompositorNodeTree:
+        try:
+            return self._get_or_create_tree()
+        except KeyError:
+            with TreeBuilder.compositor(self._name) as tree:
+                self._build_group(tree)
+            tree.tree.color_tag = self._color_tag
+            return tree.tree

{nodebpy-0.11.1 → nodebpy-0.13.0}/src/nodebpy/builder/socket.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Iterator, overload
+from typing import TYPE_CHECKING, Any, Iterator, cast, overload
 
 import bpy
 from bpy.types import (
@@ -25,6 +25,7 @@ from bpy.types import (
     NodeSocketShader,
     NodeSocketString,
     NodeSocketVector,
+    NodeTree,
 )
 from mathutils import Euler
 
@@ -55,7 +56,7 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
         self.socket = socket
         self.node = socket.node
         self._default_output_id = socket.identifier
-        self._tree = TreeBuilder(socket.node.id_data)  # type: ignore
+        self._tree = TreeBuilder(cast(NodeTree, socket.node.id_data))
 
     @property
     def tree(self) -> TreeBuilder:
@@ -100,7 +101,7 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
 
     def _dispatch_math(
         self, other: Any, operation: str, reverse: bool = False
-    ) -> "BaseNode":
+    ) -> "Math":
         """Scalar math dispatch (float). Uses the Math node."""
         from ..nodes.geometry.converter import Math
 
@@ -108,7 +109,7 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
         math_operation = "floored_modulo" if operation == "modulo" else operation
         return getattr(Math, math_operation)(*values)
 
-    def _dispatch_unary(self, operation: str) -> "BaseNode":
+    def _dispatch_unary(self, operation: str) -> "Math":
         """Scalar unary dispatch (float). Uses the Math node."""
         from ..nodes.geometry.converter import Math
 
@@ -118,7 +119,7 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
             return Math.absolute(self.socket)
         raise ValueError(f"Unknown unary operation: {operation}")
 
-    def _dispatch_floordiv(self, other: Any, reverse: bool = False) -> "BaseNode":
+    def _dispatch_floordiv(self, other: Any, reverse: bool = False) -> "Math":
         """Scalar floor division: divide then floor."""
         from ..nodes.geometry.converter import Math
 
@@ -126,7 +127,7 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
         divided = Math.divide(*values)
         return Math.floor(divided)
 
-    def _dispatch_compare(self, other: Any, operation: str) -> "BaseNode":
+    def _dispatch_compare(self, other: Any, operation: str) -> "Compare | Math":
         """Scalar comparison dispatch."""
         if isinstance(self._tree.tree, GeometryNodeTree):
             from ..nodes.geometry.manual import Compare
@@ -140,9 +141,12 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
                 "greater_than": ("greater_than", False),
                 "less_equal": ("greater_than", True),
                 "greater_equal": ("less_than", True),
+                "equal": ("compare", False),
             }
             math_op, negate = _MATH_COMPARE_MAP[operation]
             result = getattr(Math, math_op)(self.socket, other)
+            if operation == "equal":
+                result.i.value_002.default_value = 0.00001
             if negate:
                 result = Math.subtract(1.0, result._default_output_socket)
             return result
@@ -167,8 +171,8 @@ class Socket(_SocketLike, OperatorMixin, LinkingMixin):
         def __gt__(self, other: Any) -> "Compare": ...
         def __le__(self, other: Any) -> "Compare": ...
         def __ge__(self, other: Any) -> "Compare": ...
-        def __eq__(self, other: Any) -> "Compare": ...  # type: ignore[override]
-        def __ne__(self, other: Any) -> "Compare": ...  # type: ignore[override]
+        def __eq__(self, other: Any) -> "Compare": ...
+        def __ne__(self, other: Any) -> "Compare": ...
 
 
 # ---------------------------------------------------------------------------
@@ -308,7 +312,7 @@ class _VectorMixin:
 
             return getattr(Compare.vector, operation)(self.socket, other)
         else:
-            return Socket._dispatch_compare(self, other, operation)  # type: ignore[arg-type]
+            return Socket._dispatch_compare(cast("Socket", self), other, operation)
 
     if TYPE_CHECKING:
 
@@ -324,12 +328,10 @@ class _VectorMixin:
         def __rfloordiv__(self, other: Any) -> "VectorMath": ...
         def __neg__(self) -> "VectorMath": ...
         def __abs__(self) -> "VectorMath": ...
-        def __lt__(self, other: Any) -> "Compare": ...
-        def __gt__(self, other: Any) -> "Compare": ...
-        def __le__(self, other: Any) -> "Compare": ...
-        def __ge__(self, other: Any) -> "Compare": ...
-        def __eq__(self, other: Any) -> "Compare": ...  # type: ignore[override]
-        def __ne__(self, other: Any) -> "Compare": ...  # type: ignore[override]
+        def __lt__(self, other: Any) -> "Compare[NodeSocketVector]": ...
+        def __gt__(self, other: Any) -> "Compare[NodeSocketVector]": ...
+        def __le__(self, other: Any) -> "Compare[NodeSocketVector]": ...
+        def __ge__(self, other: Any) -> "Compare[NodeSocketVector]": ...
 
 
 _SEPARATE_COLOR_IDNAMES = (
@@ -356,7 +358,9 @@ class _ColorMixin:
         return SeparateColor
 
     def _separated_channel(self, channel: str) -> Socket:
+        assert self.socket.links is not None
         for link in self.socket.links:
+            assert link.to_node is not None
             if link.to_node.bl_idname in _SEPARATE_COLOR_IDNAMES:
                 return Socket(link.to_node.outputs[channel])
 
@@ -438,6 +442,40 @@ class _ColorMixin:
     def __len__(self) -> int:
         return 4
 
+    def _dispatch_math(
+        self, other: Any, operation: str, reverse: bool = False
+    ) -> "BaseNode":
+        from ..nodes.geometry import VectorMath
+
+        values = (self.socket, other) if not reverse else (other, self.socket)
+
+        if operation == "multiply":
+            if isinstance(other, (int, float)):
+                return VectorMath.scale(self.socket, other)
+            elif isinstance(other, NodeSocket) and other.type in (
+                "VALUE",
+                "FLOAT",
+                "INT",
+            ):
+                return VectorMath.scale(self.socket, other)
+            elif isinstance(other, (_SocketLike, _NodeLike)) and getattr(
+                other, "type", None
+            ) in ("VALUE", "FLOAT", "INT"):
+                return VectorMath.scale(self.socket, other._default_output_socket)
+            else:
+                return VectorMath.multiply(*values)
+        else:
+            vector_method = getattr(VectorMath, operation, None)
+            assert vector_method is not None
+            if isinstance(other, (int, float)):
+                scalar_vector = (other, other, other)
+                return (
+                    vector_method(self.socket, scalar_vector)
+                    if not reverse
+                    else vector_method(scalar_vector, self.socket)
+                )
+            return vector_method(*values)
+
 
 class _IntegerMixin:
     """Integer-specific dispatch — uses IntegerMath in geometry trees."""
@@ -475,7 +513,7 @@ class _IntegerMixin:
 
             values = (self.socket, other) if not reverse else (other, self.socket)
             return getattr(IntegerMath, operation)(*values)
-        return Socket._dispatch_math(self, other, operation, reverse)  # type: ignore[arg-type]
+        return Socket._dispatch_math(cast("Socket", self), other, operation, reverse)
 
     def _dispatch_unary(self, operation: str) -> "BaseNode":
         if self._is_geometry_tree:
@@ -485,7 +523,7 @@ class _IntegerMixin:
                 return IntegerMath.negate(self.socket)
             elif operation == "absolute":
                 return IntegerMath.absolute(self.socket)
-        return Socket._dispatch_unary(self, operation)  # type: ignore[arg-type]
+        return Socket._dispatch_unary(cast("Socket", self), operation)
 
     def _dispatch_floordiv(self, other: Any, reverse: bool = False) -> "BaseNode":
         if self._is_geometry_tree and self._other_is_integer(other):
@@ -493,14 +531,14 @@ class _IntegerMixin:
 
             values = (self.socket, other) if not reverse else (other, self.socket)
             return IntegerMath.divide_floor(*values)
-        return Socket._dispatch_floordiv(self, other, reverse)  # type: ignore[arg-type]
+        return Socket._dispatch_floordiv(cast("Socket", self), other, reverse)
 
-    def _dispatch_compare(self, other: Any, operation: str) -> "BaseNode":
+    def _dispatch_compare(self, other: Any, operation: str) -> "Compare | Math":
         if isinstance(self._tree.tree, GeometryNodeTree):
             from ..nodes.geometry.manual import Compare
 
             return getattr(Compare.integer, operation)(self.socket, other)
-        return Socket._dispatch_compare(self, other, operation)  # type: ignore[arg-type]
+        return Socket._dispatch_compare(cast("Socket", self), other, operation)
 
     if TYPE_CHECKING:
 
@@ -516,12 +554,10 @@ class _IntegerMixin:
         def __rfloordiv__(self, other: Any) -> "IntegerMath": ...
         def __neg__(self) -> "IntegerMath": ...
         def __abs__(self) -> "IntegerMath": ...
-        def __lt__(self, other: Any) -> "Compare": ...
-        def __gt__(self, other: Any) -> "Compare": ...
-        def __le__(self, other: Any) -> "Compare": ...
-        def __ge__(self, other: Any) -> "Compare": ...
-        def __eq__(self, other: Any) -> "Compare": ...  # type: ignore[override]
-        def __ne__(self, other: Any) -> "Compare": ...  # type: ignore[override]
+        def __lt__(self, other: Any) -> "Compare[NodeSocketInt]": ...
+        def __gt__(self, other: Any) -> "Compare[NodeSocketInt]": ...
+        def __le__(self, other: Any) -> "Compare[NodeSocketInt]": ...
+        def __ge__(self, other: Any) -> "Compare[NodeSocketInt]": ...
 
 
 # ---------------------------------------------------------------------------