raw signals fixed. exposing pins on subgraph node. test

Author: ilgarlunin

PyFlow/Core/GraphBase.py

@@ -11,14 +11,14 @@
 
 
 class GraphBase(object):
-
-    onInputPinCreated = Signal(object)
-    onInputPinDeleted = Signal(object)
-    onOutputPinCreated = Signal(object)
-    onOutputPinDeleted = Signal(object)
-
     def __init__(self, name, *args, **kwargs):
         super(GraphBase, self).__init__(*args, **kwargs)
+        # signals
+        self.onInputPinCreated = Signal(object)
+        self.onInputPinDeleted = Signal(object)
+        self.onOutputPinCreated = Signal(object)
+        self.onOutputPinDeleted = Signal(object)
+
         self.__name = name
         self.nodes = {}
         self.connections = {}
@@ -154,7 +154,7 @@ def findPinByName(self, pinName):
         return pin
 
     def getInputNode(self):
-        """Creates and adds graph inputs node. Note, this works only for graphs which has a parent
+        """Creates and adds to graph 'graphInputs' node. Note, this works only for graphs which has a parent
 
         pins on this node will be exposed on subgraph node as input pins
         """
@@ -164,6 +164,17 @@ def getInputNode(self):
             self.addNode(node)
         return node
 
+    def getOutputNode(self):
+        """Creates and adds to graph 'graphOutputs' node. Note, this works only for graphs which has a parent
+
+        pins on this node will be exposed on subgraph node as output pins
+        """
+        node = None
+        if GraphTree().getParentGraph(self) is not None:
+            node = getRawNodeInstance("graphOutputs", "PyflowBase")
+            self.addNode(node)
+        return node
+
     def addNode(self, node, jsonTemplate=None):
         assert(node is not None), "failed to add node, None is passed"
         if node.uid in self.nodes:

PyFlow/Core/GraphTree.py

@@ -10,11 +10,11 @@
 class GraphTree:
     """Graph tree. Here is all the data
     """
-
-    onGraphSwitched = Signal()
-
     def __init__(self, rootGraph=None):
         assert(rootGraph is not None)
+        # signals
+        self.onGraphSwitched = Signal()
+
         self.__tree = Tree()
         self.__tree.create_node(rootGraph.name, rootGraph.name, data=rootGraph)
         self.__activeGraph = rootGraph

PyFlow/Core/PinBase.py

@@ -1,3 +1,4 @@
+from blinker import Signal
 import uuid
 from copy import deepcopy
 import weakref
@@ -7,9 +8,15 @@
 
 
 class PinBase(IPin):
-    # TODO: remove dataType argument. This is redundant. We use __class__.__name__ wrapped in property
+    # TODO: remove dataType argument. We should use __class__.__name__
     def __init__(self, name, owningNode, dataType, direction, userStructClass=None):
         super(PinBase, self).__init__()
+        # signals
+        self.onPinConnected = Signal(object)
+        self.onPinDisconnected = Signal(object)
+        self.nameChanged = Signal(str)
+        self.killed = Signal()
+
         self._uid = uuid.uuid4()
         self._dataType = None
         self._userStructClass = userStructClass
@@ -33,7 +40,7 @@ def __init__(self, name, owningNode, dataType, direction, userStructClass=None):
         self.direction = direction
         ## This flag is for subgraph input nodes, to correctly establish connections
         self.actLikeDirection = direction
-        ## For rand int node
+        ## For rand int node and stuff like that
         self._alwaysPushDirty = False
         ## Can be renamed or not (for switch on string node)
         self._renamingEnabled = False
@@ -106,8 +113,8 @@ def uid(self, value):
         self._uid = value
 
     def setName(self, name):
-        oldName = self.name
         self.name = name.replace(" ", "_")
+        self.nameChanged.send(self.name)
 
     def getName(self):
         return self.owningNode().name + '.' + self.name
@@ -209,17 +216,18 @@ def setUserStruct(self, inStruct):
 
     def kill(self):
         self.owningNode().pins.pop(self.uid)
+        self.killed.send()
 
     def currentData(self):
         if self._data is None:
             return self._defaultValue
         return self._data
 
     def pinConnected(self, other):
-        pass
+        self.onPinConnected.send(other)
 
     def pinDisconnected(self, other):
-        pass
+        self.onPinDisconnected.send(other)
 
     def setClean(self):
         self.dirty = False

PyFlow/Core/Variable.py

@@ -8,19 +8,19 @@
 
 
 class Variable(ISerializable):
-
-    nameChanged = Signal()
-    valueChanged = Signal()
-    dataTypeChanged = Signal()
-    accessLevelChanged = Signal()
-    packageNameChanged = Signal()
-    uuidChanged = Signal()
-    killed = Signal()
-
     def __init__(self, value, name, dataType, accessLevel=AccessLevel.public, uid=None):
         super(Variable, self).__init__()
         assert(isinstance(name, str))
         assert(isinstance(dataType, str))
+        # signals
+        self.nameChanged = Signal()
+        self.valueChanged = Signal()
+        self.dataTypeChanged = Signal()
+        self.accessLevelChanged = Signal()
+        self.packageNameChanged = Signal()
+        self.uuidChanged = Signal()
+        self.killed = Signal()
+
         self._name = name
         self._value = value
         self._dataType = dataType

PyFlow/Packages/PyflowBase/Nodes/graphNodes.py

@@ -7,10 +7,9 @@
 class graphInputs(NodeBase):
     """Represents a group of input pins on subgraph node
     """
-    onPinCreated = Signal(object)
-
     def __init__(self, name):
         super(graphInputs, self).__init__(name)
+        self.onPinCreated = Signal(object)
 
     @staticmethod
     def pinTypeHints():
@@ -39,8 +38,10 @@ def addOutPin(self):
     def postCreate(self, jsonTemplate=None):
         super(graphInputs, self).postCreate(jsonTemplate=jsonTemplate)
         # recreate dynamically created pins
-        # before this, connect with owning graph
+        # connect with owning graph before
         self.onPinCreated.connect(self.graph().onInputPinCreated.send)
+        # add outputs
+        pass
 
     def compute(self):
         # This node is special. Output pins of this node are actually inputs pins in terms of execution and data gathering
@@ -54,10 +55,9 @@ def compute(self):
 class graphOutputs(NodeBase):
     """Represents a group of output pins on subgraph node
     """
-    onPinCreated = Signal(object)
-
     def __init__(self, name):
         super(graphOutputs, self).__init__(name)
+        self.onPinCreated = Signal(object)
 
     @staticmethod
     def pinTypeHints():
@@ -75,6 +75,14 @@ def keywords():
     def description():
         return ''
 
+    def postCreate(self, jsonTemplate=None):
+        super(graphOutputs, self).postCreate(jsonTemplate=jsonTemplate)
+        # recreate dynamically created pins
+        # connect with owning graph before
+        self.onPinCreated.connect(self.graph().onOutputPinCreated.send)
+        # add outputs
+        pass
+
     def addInPin(self):
         name = str(len(self.outputs))
         p = self.addInputPin(name, 'AnyPin')

PyFlow/Packages/PyflowBase/Nodes/subgraph.py

@@ -15,6 +15,8 @@ class subgraph(NodeBase):
     def __init__(self, name):
         super(subgraph, self).__init__(name)
         self.rawGraph = None
+        self.__inputsMap = {}  # { self.[inputPin].uid: innerPinUid }
+        self.__outputsMap = {}  # { self.[outputPin].uid: innerPinUid }
 
     @staticmethod
     def pinTypeHints():
@@ -32,21 +34,45 @@ def keywords():
     def description():
         return 'Encapsulate a graph inside a node'
 
-    def onGraphInputPinCreated(self, inPin):
-        # add companion pin for inner graphInputs node pin
-        pass
+    def onGraphInputPinCreated(self, outPin):
+        """Reaction when pin added to graphInputs node
+
+        Arguments:
+            outPin {PinBase} -- output pin on graphInputs node
+        """
+
+        # add companion pin for graphInputs node's output pin
+        subgraphInputPin = self.addInputPin(outPin.name,
+                                            outPin.dataType,
+                                            outPin.defaultValue(),
+                                            outPin.call,
+                                            outPin.constraint,
+                                            outPin.supportedDataTypes())
+        self.__inputsMap[subgraphInputPin.uid] = outPin.uid
+        # connect
+        outPin.nameChanged.connect(subgraphInputPin.setName)
+        outPin.killed.connect(subgraphInputPin.kill)
 
     def onGraphInputPinDeleted(self, inPin):
         # remove companion pin for inner graphInputs node pin
-        pass
+        print("onGraphInputPinDeleted", inPin.getName())
 
-    def onGraphOutputPinCreated(self, outPin):
-        # add companion pin for inner graphOutputs node pin
-        pass
+    def onGraphOutputPinCreated(self, inPin):
+        # add companion pin for graphOutputs node's input pin
+        subgraphOutputPin = self.addOutputPin(inPin.name,
+                                              inPin.dataType,
+                                              inPin.defaultValue(),
+                                              inPin.call,
+                                              inPin.constraint,
+                                              inPin.supportedDataTypes())
+        self.__outputsMap[subgraphOutputPin.uid] = inPin.uid
+        # connect
+        inPin.nameChanged.connect(subgraphOutputPin.setName)
+        inPin.killed.connect(subgraphOutputPin.kill)
 
     def onGraphOutputPinDeleted(self, outPin):
         # remove companion pin for inner graphOutputs node pin
-        pass
+        print("onGraphOutputPinDeleted", outPin.getName())
 
     def postCreate(self, jsonTemplate=None):
         self.rawGraph = GraphBase(self.name)

PyFlow/Tests/Test_General.py

@@ -323,7 +323,29 @@ def test_subgraph(self):
 
         # add input output nodes to expose pins to outer subgraph node
         inputs1 = GT.activeGraph().getInputNode()
+        outputs1 = GT.activeGraph().getOutputNode()
         self.assertIsNotNone(inputs1, "failed to create graph inputs node")
+        self.assertIsNotNone(outputs1, "failed to create graph outputs node")
+
+        # create out pin on graphInputs node
+        # this should expose input pin on subgraph node
+        outPin = inputs1.addOutPin()
+        self.assertEqual(len(subgraphNodeInstance.namePinInputsMap), 1, "failed to expose input pin")
+        self.assertEqual(list(subgraphNodeInstance.inputs.values())[0].name, outPin.name)
+
+        # change inner pin name and check it is reflected outside
+        outPin.setName("first")
+        self.assertEqual(list(subgraphNodeInstance.inputs.values())[0].name, outPin.name, "name is not synchronized")
+
+        # create input pin on graphOutputs node
+        # this should expose output pin on subgraph node
+        inPin = outputs1.addInPin()
+        self.assertEqual(len(subgraphNodeInstance.namePinOutputsMap), 1, "failed to expose input pin")
+        self.assertEqual(list(subgraphNodeInstance.outputs.values())[0].name, inPin.name)
+
+        # change inner pin name and check it is reflected outside
+        inPin.setName("first")
+        self.assertEqual(list(subgraphNodeInstance.outputs.values())[0].name, inPin.name, "name is not synchronized")
 
         # add simple calculation