nodeeditor-qtpy 0.8.1__py3-none-any.whl

nodeeditor/node_node.py

@@ -0,0 +1,848 @@
+# -*- coding: utf-8 -*-
+"""
+A module containing NodeEditor's class for representing `Node`.
+"""
+from collections import OrderedDict
+from qtpy.QtCore import QObject, Signal
+from nodeeditor.node_graphics_node import QDMGraphicsNode
+from nodeeditor.node_content_widget import QDMNodeContentWidget
+from nodeeditor.node_serializable import Serializable
+from nodeeditor.node_socket import Socket, LEFT_BOTTOM, LEFT_CENTER, LEFT_TOP, RIGHT_BOTTOM, RIGHT_CENTER, RIGHT_TOP
+from nodeeditor.node_socket_shapes import SOCKET_SHAPES
+import nodeeditor.node_graph as node_graph
+from nodeeditor.utils_no_qt import dumpException, pp
+
+from typing import TYPE_CHECKING, List, Optional, Tuple, Any, Union
+
+
+if TYPE_CHECKING:
+    from nodeeditor.node_graphics_view import QDMGraphicsView
+    from nodeeditor.node_edge import Edge
+    from nodeeditor.node_socket import Socket
+    from nodeeditor.node_scene import Scene
+    from nodeeditor.node_group import Group
+
+DEBUG = False
+
+
+class Node(QObject,  Serializable):
+    """
+    Class representing `Node` in the `Scene`.
+    """
+    # Signal emitted when node position changes (after user finishes dragging)
+    positionChanged = Signal(object)  # Emits the Node object
+    # Signal emitted when the floating label text is changed by user or code
+    labelChanged = Signal(str)
+
+    GraphicsNode_class = QDMGraphicsNode
+    NodeContent_class = QDMNodeContentWidget
+    Socket_class = Socket
+
+    def __init__(self, scene: 'Scene', title: str = "Undefined Node", inputs: list = [], outputs: list = [], input_text: list = [], output_text: list = []) -> None:
+        """
+
+        :param scene: reference to the :class:`~nodeeditor.node_scene.Scene`
+        :type scene: :class:`~nodeeditor.node_scene.Scene`
+        :param title: Node Title shown in Scene
+        :type title: str
+        :param inputs: list of :class:`~nodeeditor.node_socket.Socket` types from which the `Sockets` will be auto created
+        :param outputs: list of :class:`~nodeeditor.node_socket.Socket` types from which the `Sockets` will be auto created
+
+        :Instance Attributes:
+
+            - **scene** - reference to the :class:`~nodeeditor.node_scene.Scene`
+            - **grNode** - Instance of :class:`~nodeeditor.node_graphics_node.QDMGraphicsNode` handling graphical representation in the ``QGraphicsScene``. Automatically created in the constructor
+            - **content** - Instance of :class:`~nodeeditor.node_graphics_content.QDMGraphicsContent` which is child of ``QWidget`` representing container for all inner widgets inside of the Node. Automatically created in the constructor
+            - **inputs** - list containin Input :class:`~nodeeditor.node_socket.Socket` instances
+            - **outputs** - list containin Output :class:`~nodeeditor.node_socket.Socket` instances
+
+        """
+        super().__init__()  # Initialize QObject
+        super(Serializable).__init__()  # Initialize Serializable
+        self._title = title
+        self.scene = scene
+
+        # just to be sure, init these variables
+        self.content: QDMNodeContentWidget
+        self.grNode: QDMGraphicsNode
+
+        self.initInnerClasses()
+        self.initSettings()
+
+        self.title = title
+
+        self.scene.addNode(self)
+        self.scene.grScene.addItem(self.grNode)
+
+        # create socket for inputs and outputs
+        self.inputs: List['Socket'] = []
+        self.outputs: List['Socket'] = []
+        self.initSockets(inputs, outputs, input_text, output_text)
+
+        # dirty and evaluation
+        self._is_dirty = False
+        self._is_invalid = False
+
+        # grouping support (single parent Group or None; see nodeeditor.node_group)
+        self.parent_group: Optional["Group"] = None
+
+        # The scene may already be at low zoom (a restore into a zoomed-out
+        # view): sockets and the content proxy were built after Qt reported
+        # this node joining the scene, so push the current state onto them.
+        sync_detail = getattr(self.grNode, "syncDetailVisibility", None)
+        if sync_detail is not None:
+            sync_detail()
+
+    def __str__(self) -> str:
+        """Return a short identifying string of this `Node`."""
+        return "<%s:%s %s..%s>" % (self.title, self.__class__.__name__, hex(id(self))[2:5], hex(id(self))[-3:])
+
+    @property
+    def title(self):
+        """
+        Title shown in the scene
+
+        :getter: return current Node title
+        :setter: sets Node title and passes it to Graphics Node class
+        :type: ``str``
+        """
+        return self._title
+
+    @title.setter
+    def title(self, value) -> None:
+        self._title = value
+        self.grNode.title = self._title
+
+    def setNodeLabel(self, text: str, store_history: bool = True) -> None:
+        """Set the floating single-line label above the node.
+
+        :param text: label text; empty string hides the label
+        :param store_history: store undo history entry (skip during load/deserialize)
+        """
+        if self.grNode is None or not hasattr(self.grNode, 'setLabelText'):
+            return
+        self.grNode.setLabelText(text)
+        try:
+            self.labelChanged.emit(self.grNode.labelText())
+        except Exception:
+            pass
+        if store_history:
+            try:
+                self.scene.history.storeHistory("Node label changed", setModified=True)
+            except Exception:
+                pass
+
+    def getNodeLabel(self) -> str:
+        """Return floating label text (``""`` when none)."""
+        if self.grNode is None or not hasattr(self.grNode, 'labelText'):
+            return ""
+        try:
+            return self.grNode.labelText()
+        except Exception:
+            return ""
+
+    def clearNodeLabel(self, store_history: bool = True) -> None:
+        """Remove the floating label."""
+        self.setNodeLabel("", store_history=store_history)
+
+    def setNodeLabelVisible(self, visible: bool) -> None:
+        """Show or hide the floating label of this `Node`.
+
+        The label stays hidden while it carries no text.
+
+        :param visible: ``True`` shows the label, ``False`` hides it
+        :type visible: ``bool``
+        """
+        if self.grNode is None or not hasattr(self.grNode, 'setLabelVisible'):
+            return
+        self.grNode.setLabelVisible(visible)
+
+    def isNodeLabelVisible(self) -> bool:
+        """Is the floating label of this `Node` currently visible?
+
+        :return: ``True`` if the label is visible
+        :rtype: ``bool``
+        """
+        if self.grNode is None or not hasattr(self.grNode, 'isLabelVisible'):
+            return False
+        try:
+            return bool(self.grNode.isLabelVisible())
+        except Exception:
+            return False
+
+    def setNodeLabelOffset(self, offset: float) -> None:
+        """Set the gap between the top of this `Node` and the bottom of its floating label.
+
+        :param offset: gap in pixels
+        :type offset: ``float``
+        """
+        if self.grNode is None or not hasattr(self.grNode, 'setLabelOffset'):
+            return
+        self.grNode.setLabelOffset(offset)
+
+    @property
+    def pos(self):
+        """
+        Retrieve Node's position in the Scene
+
+        :return: Node position
+        :rtype: ``QPointF``
+        """
+        return self.grNode.pos()        # QPointF
+
+    def setPos(self, x: float, y: float) -> None:
+        """
+        Sets position of the Graphics Node
+
+        :param x: X `Scene` position
+        :param y: Y `Scene` position
+        """
+        # Moving the graphics item fires ``itemChange(ItemPositionHasChanged)``,
+        # which refreshes the connected edges. The loop that used to live here
+        # did the same work again, and called ``calcPath()`` a second time
+        # before immediately invalidating that path, so it was pure waste.
+        self.grNode.setPos(x, y)
+
+    def initInnerClasses(self) -> None:
+        """Sets up graphics Node (PyQt) and Content Widget"""
+        node_content_class = self.getNodeContentClass()
+        graphics_node_class = self.getGraphicsNodeClass()
+        if node_content_class is not None:
+            self.content = node_content_class(self)
+        if graphics_node_class is not None:
+            self.grNode = graphics_node_class(self)
+
+    def getNodeContentClass(self):
+        """Returns class representing nodeeditor content"""
+        return self.__class__.NodeContent_class
+
+    def getGraphicsNodeClass(self):
+        """Returns class representing the graphics node"""
+        return self.__class__.GraphicsNode_class
+
+    def initSettings(self) -> None:
+        """Initialize properties and socket information"""
+        self.socket_spacing = 22
+        # Todo: set input_multi_edged option.
+        self.input_socket_position = LEFT_BOTTOM
+        self.output_socket_position = RIGHT_TOP
+        self.input_multi_edged = False
+        self.output_multi_edged = True
+        #: shape used by this node's input sockets, keyed by socket type.
+        #: ``'*'`` is the wildcard for every type the map does not name.
+        self.input_socket_shapes: dict = {}
+        #: shape used by this node's output sockets, keyed by socket type
+        self.output_socket_shapes: dict = {}
+        self.socket_offsets = {
+            LEFT_BOTTOM: -1,
+            LEFT_CENTER: -1,
+            LEFT_TOP: -1,
+            RIGHT_BOTTOM: 1,
+            RIGHT_CENTER: 1,
+            RIGHT_TOP: 1,
+        }
+
+    def getSocketShapeName(self, socket_type, is_input: bool) -> str:
+        """Name of the shape used by a socket of ``socket_type`` on this node.
+
+        The side's own map is consulted first, then its ``'*'`` wildcard
+        entry, and the circle is the last resort. Types that are not mapped
+        keep the classic circle.
+
+        :param socket_type: the socket's type, as passed to ``initSockets``
+        :param is_input: ``True`` for an input socket
+        :return: the registered shape name
+        :rtype: ``str``
+
+        Example::
+
+            class MyNode(Node):
+                def initSettings(self):
+                    super().initSettings()
+                    self.input_socket_shapes = {1: 'chevron'}
+                    self.output_socket_shapes = {'*': 'triangle'}
+        """
+        if is_input:
+            mapping = getattr(self, "input_socket_shapes", None)
+        else:
+            mapping = getattr(self, "output_socket_shapes", None)
+
+        name = None
+        if isinstance(mapping, dict):
+            name = mapping.get(socket_type)
+            if name is None:
+                name = mapping.get("*")
+        # an unregistered name draws as the circle rather than breaking
+        if isinstance(name, str) and name in SOCKET_SHAPES:
+            return name
+        return "circle"
+
+    def initSockets(self, inputs: list, outputs: list,
+                    input_text: list = [], output_text: list = [],
+                    reset: bool = True) -> None:
+        """
+        Create sockets for inputs and outputs
+
+        :param inputs: list of Socket Types (int)
+        :type inputs: ``list``
+        :param outputs: list of Socket Types (int)
+        :type outputs: ``list``
+        :param input_text: list of Socket Types (int)
+        :type input_text: ``list``
+        :param output_text: list of Socket Types (int)
+        :type output_text: ``list``
+        :param reset: if ``True`` destroys and removes old `Sockets`
+        :type reset: ``bool``
+        """
+
+        # Initialize empty lists if None provided
+        input_text = input_text or []
+        output_text = output_text or []
+
+        if reset:
+            # clear old sockets
+            if hasattr(self, 'inputs') and hasattr(self, 'outputs'):
+                # remove grSockets from scene
+                for socket in (self.inputs + self.outputs):
+                    self.scene.grScene.removeItem(socket.grSocket)
+                self.inputs = []
+                self.outputs = []
+
+        # create new sockets
+        for i, item in enumerate(inputs):
+            # Get text if available, otherwise empty string
+            text = input_text[i] if i < len(input_text) else ""
+            socket = self.__class__.Socket_class(
+                node=self,
+                index=i,
+                position=self.input_socket_position,
+                socket_type=item,
+                multi_edges=self.input_multi_edged,
+                count_on_this_node_side=len(inputs),
+                is_input=True
+            )
+            socket.grSocket.setText(text)
+            self.inputs.append(socket)
+
+        for i, item in enumerate(outputs):
+            # Get text if available, otherwise empty string
+            text = output_text[i] if i < len(output_text) else ""
+            socket = self.__class__.Socket_class(
+                node=self,
+                index=i,
+                position=self.output_socket_position,
+                socket_type=item,
+                multi_edges=self.output_multi_edged,
+                count_on_this_node_side=len(outputs),
+                is_input=False
+            )
+            socket.grSocket.setText(text)
+            self.outputs.append(socket)
+
+    def onEdgeConnectionChanged(self, new_edge: 'Edge') -> None:
+        """
+        Event handling that any connection (`Edge`) has changed. Currently not used...
+
+        :param new_edge: reference to the changed :class:`~nodeeditor.node_edge.Edge`
+        :type new_edge: :class:`~nodeeditor.node_edge.Edge`
+        """
+        pass
+
+    def onInputChanged(self, socket: 'Socket') -> None:
+        """Event handling when Node's input Edge has changed. We auto-mark this `Node` to be `Dirty` with all it's
+        descendants
+
+        :param socket: reference to the changed :class:`~nodeeditor.node_socket.Socket`
+        :type socket: :class:`~nodeeditor.node_socket.Socket`
+        """
+        self.markDirty()
+        self.markDescendantsDirty()
+
+    def onDeserialized(self, data: dict) -> None:
+        """Event manually called when this node was deserialized. Currently called when node is deserialized from scene
+        Passing `data` containing the data which have been deserialized """
+        pass
+
+    def onDoubleClicked(self, event) -> None:
+        """Event handling double click on Graphics Node in `Scene`"""
+        pass
+
+    def doSelect(self, new_state: bool = True) -> None:
+        """Shortcut method for selecting/deselecting the `Node`
+
+        :param new_state: ``True`` if you want to select the `Node`. ``False`` if you want to deselect the `Node`
+        :type new_state: ``bool``
+        """
+        self.grNode.doSelect(new_state)
+
+    def isSelected(self):
+        """Returns ``True`` if current `Node` is selected"""
+        return self.grNode.isSelected()
+
+    def hasConnectedEdge(self, edge: 'Edge') -> bool:
+        """Returns ``True`` if edge is connected to any :class:`~nodeeditor.node_socket.Socket` of this `Node`"""
+        for socket in (self.inputs + self.outputs):
+            if socket.isConnected(edge):
+                return True
+        return False
+
+    def getSocketPosition(self, index: int, position: int, num_out_of: int = 1) -> List[float]:
+        """
+        Get the relative `x, y` position of a :class:`~nodeeditor.node_socket.Socket`. This is used for placing
+        the `Graphics Sockets` on `Graphics Node`.
+
+        :param index: Order number of the Socket. (0, 1, 2, ...)
+        :type index: ``int``
+        :param position: `Socket Position Constant` describing where the Socket is located. See :ref:`socket-position-constants`
+        :type position: ``int``
+        :param num_out_of: Total number of Sockets on this `Socket Position`
+        :type num_out_of: ``int``
+        :return: Position of described Socket on the `Node`
+        :rtype: ``x, y``
+        """
+        x = self.socket_offsets[position] if (position in (
+            LEFT_TOP, LEFT_CENTER, LEFT_BOTTOM)) else self.grNode.width + self.socket_offsets[position]
+
+        if position in (LEFT_BOTTOM, RIGHT_BOTTOM):
+            # start from bottom
+            y = self.grNode.height - self.grNode.edge_roundness - \
+                self.grNode.title_vertical_padding - index * self.socket_spacing
+        elif position in (LEFT_CENTER, RIGHT_CENTER):
+            num_sockets = num_out_of
+            node_height = self.grNode.height
+            top_offset = self.grNode.title_height + 2 * \
+                self.grNode.title_vertical_padding + self.grNode.edge_padding
+            available_height = node_height - top_offset
+
+            total_height_of_all_sockets = num_sockets * self.socket_spacing
+            new_top = available_height - total_height_of_all_sockets
+
+            # y = top_offset + index * self.socket_spacing + new_top / 2
+            y = top_offset + available_height / \
+                2.0 + (index-0.5)*self.socket_spacing
+            if num_sockets > 1:
+                y -= self.socket_spacing * (num_sockets-1)/2
+
+        elif position in (LEFT_TOP, RIGHT_TOP):
+            # start from top
+            y = self.grNode.title_height + self.grNode.title_vertical_padding + \
+                self.grNode.edge_roundness + index * self.socket_spacing
+        else:
+            # this should never happen
+            y = 0
+
+        return [x, y]
+
+    def getSocketScenePosition(self, socket: 'Socket') -> Tuple[float, float]:
+        """
+        Get absolute Socket position in the Scene
+
+        :param socket: `Socket` which position we want to know
+        :return: (x, y) Socket's scene position
+        """
+        nodepos = self.grNode.pos()
+        socketpos = self.getSocketPosition(
+            socket.index, socket.position, socket.count_on_this_node_side)
+        return (nodepos.x() + socketpos[0], nodepos.y() + socketpos[1])
+
+    def updateConnectedEdges(self) -> None:
+        """Recalculate (Refresh) positions of all connected `Edges`. Used for updating Graphics Edges"""
+        for socket in self.inputs + self.outputs:
+            # if socket.hasEdge():
+            for edge in socket.edges:
+                edge.updatePositions()
+
+    def remove(self) -> None:
+        """
+        Safely remove this Node (detaches from parent Group first)
+        """
+        # detach from group first so bounds/stubs update without this node
+        try:
+            grp = getattr(self, 'parent_group', None)
+            if grp is not None:
+                try:
+                    grp.removeNode(self, update_bounds=False)
+                except Exception:
+                    try:
+                        self.parent_group = None
+                    except Exception:
+                        pass
+        except Exception:
+            pass
+        if DEBUG:
+            print("> Removing Node", self)
+        if DEBUG:
+            print(" - remove all edges from sockets")
+        for socket in (self.inputs+self.outputs):
+            # if socket.hasEdge():
+            for edge in socket.edges.copy():
+                if DEBUG:
+                    print("    - removing from socket:", socket, "edge:", edge)
+                edge.remove()
+        if DEBUG:
+            print(" - remove grNode")
+        try:
+            if self.grNode is not None:
+                self.scene.grScene.removeItem(self.grNode)
+        except Exception:
+            pass
+        self.grNode = None
+        if DEBUG:
+            print(" - remove node from the scene")
+        self.scene.removeNode(self)
+        if DEBUG:
+            print(" - everything was done.")
+
+    # node evaluation stuff
+
+    def isDirty(self) -> bool:
+        """Is this node marked as `Dirty`
+
+        :return: ``True`` if `Node` is marked as `Dirty`
+        :rtype: ``bool``
+        """
+        return self._is_dirty
+
+    def markDirty(self, new_value: bool = True) -> None:
+        """Mark this `Node` as `Dirty`. See :ref:`evaluation` for more
+
+        :param new_value: ``True`` if this `Node` should be `Dirty`. ``False`` if you want to un-dirty this `Node`
+        :type new_value: ``bool``
+        """
+        self._is_dirty = new_value
+        if self._is_dirty:
+            self.onMarkedDirty()
+
+    def onMarkedDirty(self) -> None:
+        """Called when this `Node` has been marked as `Dirty`. This method is supposed to be overridden"""
+        pass
+
+    def markChildrenDirty(self, new_value: bool = True) -> None:
+        """Mark all first level children of this `Node` to be `Dirty`. Not this `Node` it self. Not other descendants
+
+        :param new_value: ``True`` if children should be `Dirty`. ``False`` if you want to un-dirty children
+        :type new_value: ``bool``
+        """
+        for other_node in self.getChildrenNodes():
+            other_node.markDirty(new_value)
+
+    def markDescendantsDirty(self, new_value: bool = True) -> None:
+        """Mark all children and descendants of this `Node` to be `Dirty`. Not this `Node` it self
+
+        The traversal is iterative and keeps a visited set, so a graph with a
+        cycle terminates instead of exhausting the interpreter's recursion
+        limit, and a node reachable through several paths is visited once
+        rather than once per path.
+
+        :param new_value: ``True`` if children and descendants should be `Dirty`. ``False`` if you want to un-dirty children and descendants
+        :type new_value: ``bool``
+        """
+        for other_node in node_graph.descendants(self.scene, self):
+            other_node.markDirty(new_value)
+
+    def isInvalid(self) -> bool:
+        """Is this node marked as `Invalid`?
+
+        :return: ``True`` if `Node` is marked as `Invalid`
+        :rtype: ``bool``
+        """
+        return self._is_invalid
+
+    def markInvalid(self, new_value: bool = True) -> None:
+        """Mark this `Node` as `Invalid`. See :ref:`evaluation` for more
+
+        :param new_value: ``True`` if this `Node` should be `Invalid`. ``False`` if you want to make this `Node` valid
+        :type new_value: ``bool``
+        """
+        self._is_invalid = new_value
+        if self._is_invalid:
+            self.onMarkedInvalid()
+
+    def onMarkedInvalid(self) -> None:
+        """Called when this `Node` has been marked as `Invalid`. This method is supposed to be overridden"""
+        pass
+
+    def markChildrenInvalid(self, new_value: bool = True) -> None:
+        """Mark all first level children of this `Node` to be `Invalid`. Not this `Node` it self. Not other descendants
+
+        :param new_value: ``True`` if children should be `Invalid`. ``False`` if you want to make children valid
+        :type new_value: ``bool``
+        """
+        for other_node in self.getChildrenNodes():
+            other_node.markInvalid(new_value)
+
+    def markDescendantsInvalid(self, new_value: bool = True) -> None:
+        """Mark all children and descendants of this `Node` to be `Invalid`. Not this `Node` it self
+
+        The traversal is iterative and keeps a visited set, so a graph with a
+        cycle terminates instead of exhausting the interpreter's recursion
+        limit, and a node reachable through several paths is visited once
+        rather than once per path.
+
+        :param new_value: ``True`` if children and descendants should be `Invalid`. ``False`` if you want to make children and descendants valid
+        :type new_value: ``bool``
+        """
+        for other_node in node_graph.descendants(self.scene, self):
+            other_node.markInvalid(new_value)
+
+    def eval(self, index: int = 0) -> int:
+        """Evaluate this `Node`. This is supposed to be overridden. See :ref:`evaluation` for more"""
+        self.markDirty(False)
+        self.markInvalid(False)
+        return 0
+
+    def evalChildren(self) -> None:
+        """Evaluate all children of this `Node`"""
+        for node in self.getChildrenNodes():
+            node.eval()
+
+    # traversing nodes functions
+
+    def getChildrenNodes(self) -> 'List[Node]':
+        """
+        Retreive all first-level children connected to this `Node` `Outputs`
+
+        :return: list of `Nodes` connected to this `Node` from all `Outputs`
+        :rtype: List[:class:`~nodeeditor.node_node.Node`]
+        """
+        if self.outputs == []:
+            return []
+        other_nodes = []
+        for ix in range(len(self.outputs)):
+            for edge in self.outputs[ix].edges:
+                other_node = edge.getOtherSocket(self.outputs[ix]).node
+                other_nodes.append(other_node)
+        return other_nodes
+
+    def getInput(self, index: int = 0) -> Optional['Node']:
+        """
+        Get the **first**  `Node` connected to the  Input specified by `index`
+
+        :param index: Order number of the `Input Socket`
+        :type index: ``int``
+        :return: :class:`~nodeeditor.node_node.Node` which is connected to the specified `Input` or ``None`` if
+            there is no connection or the index is out of range
+        :rtype: :class:`~nodeeditor.node_node.Node` or ``None``
+        """
+        try:
+            input_socket = self.inputs[index]
+            if len(input_socket.edges) == 0:
+                return None
+            connecting_edge = input_socket.edges[0]
+            other_socket = connecting_edge.getOtherSocket(self.inputs[index])
+            return other_socket.node
+        except Exception as e:
+            dumpException(e)
+            return None
+
+    def getInputWithSocket(self, index: int = 0) -> Union[Tuple['Node', 'Socket'], Tuple[None, None]]:
+        """
+        Get the **first**  `Node` connected to the Input specified by `index` and the connection `Socket`
+
+        :param index: Order number of the `Input Socket`
+        :type index: ``int``
+        :return: Tuple containing :class:`~nodeeditor.node_node.Node` and :class:`~nodeeditor.node_socket.Socket` which
+            is connected to the specified `Input` or ``None`` if there is no connection or the index is out of range
+        :rtype: (:class:`~nodeeditor.node_node.Node`, :class:`~nodeeditor.node_socket.Socket`)
+        """
+        try:
+            input_socket = self.inputs[index]
+            if len(input_socket.edges) == 0:
+                return None, None
+            connecting_edge = input_socket.edges[0]
+            other_socket = connecting_edge.getOtherSocket(self.inputs[index])
+            return other_socket.node, other_socket
+        except Exception as e:
+            dumpException(e)
+            return None, None
+
+    def getInputWithSocketIndex(self, index: int = 0) -> Union[Tuple['Node', int], Tuple[None, None]]:
+        """
+        Get the **first**  `Node` connected to the Input specified by `index` and the connection `Socket`
+
+        :param index: Order number of the `Input Socket`
+        :type index: ``int``
+        :return: Tuple containing :class:`~nodeeditor.node_node.Node` and :class:`~nodeeditor.node_socket.Socket` which
+            is connected to the specified `Input` or ``None`` if there is no connection or the index is out of range
+        :rtype: (:class:`~nodeeditor.node_node.Node`, int)
+        """
+        try:
+            edge = self.inputs[index].edges[0]
+            socket = edge.getOtherSocket(self.inputs[index])
+            return socket.node, socket.index
+        except IndexError:
+            # print("EXC: Trying to get input with socket index %d, but none is attached to" % index, self)
+            return None, None
+        except Exception as e:
+            dumpException(e)
+            return None, None
+
+    def getInputs(self, index: int = 0) -> 'List[Node]':
+        """
+        Get **all** `Nodes` connected to the Input specified by `index`
+
+        :param index: Order number of the `Input Socket`
+        :type index: ``int``
+        :return: all :class:`~nodeeditor.node_node.Node` instances which are connected to the
+            specified `Input` or ``[]`` if there is no connection or the index is out of range
+        :rtype: List[:class:`~nodeeditor.node_node.Node`]
+        """
+        ins = []
+        for edge in self.inputs[index].edges:
+            other_socket = edge.getOtherSocket(self.inputs[index])
+            ins.append(other_socket.node)
+        return ins
+
+    def getOutputs(self, index: int = 0) -> 'List[Node]':
+        """
+        Get **all** `Nodes` connected to the Output specified by `index`
+
+        :param index: Order number of the `Output Socket`
+        :type index: ``int``
+        :return: all :class:`~nodeeditor.node_node.Node` instances which are connected to the
+            specified `Output` or ``[]`` if there is no connection or the index is out of range
+        :rtype: List[:class:`~nodeeditor.node_node.Node`]
+        """
+        outs = []
+        for edge in self.outputs[index].edges:
+            other_socket = edge.getOtherSocket(self.outputs[index])
+            outs.append(other_socket.node)
+        return outs
+
+    # serialization functions
+
+    def serialize(self) -> OrderedDict:
+        """
+        Serialize this `Node` into an ``OrderedDict`` for storing in memory or on disk.
+
+        :return: data serialized in ``OrderedDict``
+        :rtype: ``OrderedDict``
+        """
+        inputs, outputs = [], []
+        for socket in self.inputs:
+            inputs.append(socket.serialize())
+        for socket in self.outputs:
+            outputs.append(socket.serialize())
+        ser_content = self.content.serialize() if isinstance(
+            self.content, Serializable) else {}
+        try:
+            label_text = self.getNodeLabel()
+        except Exception:
+            label_text = ""
+        try:
+            label_visible = self.isNodeLabelVisible() if label_text else False
+        except Exception:
+            label_visible = False
+        try:
+            label_offset = float(self.grNode.labelOffset()) if self.grNode is not None and hasattr(self.grNode, 'labelOffset') else 10.0
+        except Exception:
+            label_offset = 10.0
+        return OrderedDict([
+            ('id', self.id),
+            ('title', self.title),
+            ('pos_x', self.grNode.scenePos().x()),
+            ('pos_y', self.grNode.scenePos().y()),
+            ('inputs', inputs),
+            ('outputs', outputs),
+            ('content', ser_content),
+            ('label_text', label_text),
+            ('label_visible', label_visible),
+            ('label_offset', label_offset),
+        ])
+
+    def deserialize(self, data: dict, hashmap: dict = {}, restore_id: bool = True, *args, **kwargs) -> bool:
+        """
+        Deserialize this `Node` from a ``dict`` of serialized data.
+
+        Sockets missing in the data are created, sockets already present are reused.
+
+        :param data: Dictionary containing serialized data
+        :type data: ``dict``
+        :param hashmap: Helper dictionary containing references (by id == key) to existing objects
+        :type hashmap: ``dict``
+        :param restore_id: True if we are creating new Sockets. False is useful when loading existing
+            Sockets of which we want to keep the existing object's `id`.
+        :type restore_id: bool
+        :return: ``True`` if deserialization was successful, otherwise ``False``
+        :rtype: ``bool``
+        """
+        try:
+            if restore_id:
+                self.id = data['id']
+            hashmap[data['id']] = self
+
+            self.setPos(data['pos_x'], data['pos_y'])
+            self.title = data['title']
+
+            # floating label (backward compatible: old files have no keys)
+            try:
+                if self.grNode is not None and hasattr(self.grNode, 'setLabelText'):
+                    self.grNode.setLabelOffset(float(data.get('label_offset', 10.0)))
+                    self.grNode.setLabelText(data.get('label_text', ""))
+                    self.grNode.setLabelVisible(bool(data.get('label_visible', bool(data.get('label_text', "")))))
+            except Exception:
+                pass
+
+            data['inputs'].sort(
+                key=lambda socket: socket['index'] + socket['position'] * 10000)
+            data['outputs'].sort(
+                key=lambda socket: socket['index'] + socket['position'] * 10000)
+            num_inputs = len(data['inputs'])
+            num_outputs = len(data['outputs'])
+
+            # print("> deserialize node,   num inputs:", num_inputs, "num outputs:", num_outputs)
+            # pp(data)
+
+            # possible way to do it is reuse existing sockets...
+            # dont create new ones if not necessary
+
+            for socket_data in data['inputs']:
+                found = None
+                for socket in self.inputs:
+                    # print("\t", socket, socket.index, "=?", socket_data['index'])
+                    if socket.index == socket_data['index']:
+                        found = socket
+                        break
+                if found is None:
+                    # print("deserialization of socket data has not found input socket with index:", socket_data['index'])
+                    # print("actual socket data:", socket_data)
+                    # we can create new socket for this
+                    found = self.__class__.Socket_class(
+                        node=self, index=socket_data['index'], position=socket_data['position'],
+                        socket_type=socket_data['socket_type'], count_on_this_node_side=num_inputs,
+                        is_input=True
+                    )
+                    # append newly created input to the list
+                    self.inputs.append(found)
+                found.deserialize(socket_data, hashmap, restore_id)
+
+            for socket_data in data['outputs']:
+                found = None
+                for socket in self.outputs:
+                    # print("\t", socket, socket.index, "=?", socket_data['index'])
+                    if socket.index == socket_data['index']:
+                        found = socket
+                        break
+                if found is None:
+                    # print("deserialization of socket data has not found output socket with index:", socket_data['index'])
+                    # print("actual socket data:", socket_data)
+                    # we can create new socket for this
+                    found = self.__class__.Socket_class(
+                        node=self, index=socket_data['index'], position=socket_data['position'],
+                        socket_type=socket_data['socket_type'], count_on_this_node_side=num_outputs,
+                        is_input=False
+                    )
+                    # append newly created output to the list
+                    self.outputs.append(found)
+                found.deserialize(socket_data, hashmap, restore_id)
+
+        except Exception as e:
+            dumpException(e)
+
+        # also deserialize the content of the node
+        # so far the rest was ok, now as last step the content...
+        if isinstance(self.content, Serializable):
+            res = self.content.deserialize(data['content'], hashmap)
+            return res
+
+        return True