Rename AutoNode methods to match name style

Author: ArnoChenFx

example_auto_nodes.py

@@ -59,7 +59,7 @@ def print_functions(graph, node):
 
 
 def toggle_auto_cook(graph, node):
-    node.autoCook = not node.autoCook
+    node.auto_cook = not node.auto_cook
 
 
 def enter_node(graph, node):

example_auto_nodes/data_node.py

@@ -27,7 +27,7 @@ def __init__(self):
         self.map = {0: "x", 1: "y", 2: "z", 3: "w"}
 
     def run(self):
-        value = self.getInputData(0)
+        value = self.get_input_data(0)
         if type(value) is not list:
             self.error("Input data not list")
             return
@@ -59,7 +59,7 @@ def __init__(self):
     def run(self):
         result = []
         for i in range(4):
-            data = self.getInputData(i)
+            data = self.get_input_data(i)
             if data is not None:
                 result.append(data)
 
@@ -92,15 +92,15 @@ def run(self):
         method = self.get_property("method")
         try:
             if method == "all to int":
-                data = int(float(self.getInputData(0)))
+                data = int(float(self.get_input_data(0)))
             elif method == "all to float":
-                data = float(self.getInputData(0))
+                data = float(self.get_input_data(0))
             elif method == "all to string":
-                data = str(self.getInputData(0))
+                data = str(self.get_input_data(0))
             elif method == "eval string":
-                data = eval(self.getInputData(0))
+                data = eval(self.get_input_data(0))
             elif method == "all to list":
-                data = list(self.getInputData(0))
+                data = list(self.get_input_data(0))
             self.set_property("out", data)
         except Exception as error:
             self.error(error)

example_auto_nodes/logic_nodes.py

@@ -18,10 +18,10 @@ def __init__(self):
         self.create_property('out', None)
 
     def run(self):
-        if self.getInputData(self.condition):
-            result = self.getInputData(self._then)
+        if self.get_input_data(self.condition):
+            result = self.get_input_data(self._then)
         else:
-            result = self.getInputData(self._else)
+            result = self.get_input_data(self._else)
 
         self.set_property('out', result)
 
@@ -67,8 +67,8 @@ def addFunction(self, prop, func):
         self.cook()
 
     def run(self):
-        a = self.getInputData(self.a)
-        b = self.getInputData(self.b)
+        a = self.get_input_data(self.a)
+        b = self.get_input_data(self.b)
 
         if a is None or (b is None and 'b' in self.func):
             self.error("No inputs!")

example_auto_nodes/node_base/auto_node.py

@@ -1,5 +1,4 @@
-from NodeGraphQt import BaseNode, SubGraph, Port, QtCore
-from NodeGraphQt.constants import NODE_PROP
+from NodeGraphQt import BaseNode, Port, QtCore
 from . utils import update_node_down_stream
 import traceback
 import hashlib
@@ -34,43 +33,43 @@ class AutoNode(BaseNode, QtCore.QObject):
     def __init__(self, defaultInputType=None, defaultOutputType=None):
         super(AutoNode, self).__init__()
         QtCore.QObject.__init__(self)
-        self._needCook = True
+        self._need_cook = True
         self._error = False
         self.matchTypes = [['float', 'int']]
         self.errorColor = (200, 50, 50)
         self.stopCookColor = (200, 200, 200)
         self._cryptoColors = CryptoColors()
 
-        self.create_property('autoCook', True)
+        self.create_property('auto_cook', True)
         self.create_property('default_color', self.get_property('color'))
         self.defaultValue = None
         self.defaultInputType = defaultInputType
         self.defaultOutputType = defaultOutputType
 
-        self._cookTime = 0.0
+        self._cook_time = 0.0
         self._toolTip = self._setup_tool_tip()
 
     @property
-    def autoCook(self):
+    def auto_cook(self):
         """
         Returns whether the node can update stream automatically.
         """
 
-        return self.get_property('autoCook')
+        return self.get_property('auto_cook')
 
-    @autoCook.setter
-    def autoCook(self, mode):
+    @auto_cook.setter
+    def auto_cook(self, mode):
         """
         Set whether the node can update stream automatically.
 
         Args:
             mode(bool).
         """
 
-        if mode is self.autoCook:
+        if mode is self.auto_cook:
             return
 
-        self.model.set_property('autoCook', mode)
+        self.model.set_property('auto_cook', mode)
         if mode:
             self.set_property('color', self.get_property('default_color'))
         else:
@@ -79,23 +78,23 @@ def autoCook(self, mode):
             self.set_property('color', self.stopCookColor)
 
     @property
-    def cookTime(self):
+    def cook_time(self):
         """
         Returns the last cooked time of the node.
         """
 
-        return self._cookTime
+        return self._cook_time
 
-    @cookTime.setter
-    def cookTime(self, cook_time):
+    @cook_time.setter
+    def cook_time(self, cook_time):
         """
         Set the last cooked time of the node.
 
         Args:
             cook_time(float).
         """
 
-        self._cookTime = cook_time
+        self._cook_time = cook_time
         self._update_tool_tip()
 
     @property
@@ -111,17 +110,17 @@ def update_stream(self, forceCook=False):
         Update all down stream nodes.
 
         Args:
-            forceCook(bool): if True, it will ignore the autoCook and so on.
+            forceCook(bool): if True, it will ignore the auto_cook and so on.
         """
 
         if not forceCook:
-            if not self.autoCook or not self._needCook:
+            if not self.auto_cook or not self.get_input_data:
                 return
             if self.graph is not None and not self.graph.auto_update:
                 return
         update_node_down_stream(self)
 
-    def getData(self, port):
+    def get_data(self, port):
         """
         Get node data by port.
         Most time it will called by output nodes of the node.
@@ -135,7 +134,7 @@ def getData(self, port):
 
         return self.get_property(port.name())
 
-    def getInputData(self, port):
+    def get_input_data(self, port):
         """
         Get input data by input port name/index/object.
 
@@ -154,7 +153,7 @@ def getInputData(self, port):
             return copy.deepcopy(self.defaultValue)
 
         for from_port in from_ports:
-            data = from_port.node().getData(from_port)
+            data = from_port.node().get_data(from_port)
             return copy.deepcopy(data)
 
     def when_disabled(self):
@@ -164,16 +163,16 @@ def when_disabled(self):
 
         num = max(0, len(self.input_ports())-1)
         for index, out_port in enumerate(self.output_ports()):
-            self.model.set_property(out_port.name(), self.getInputData(min(index, num)))
+            self.model.set_property(out_port.name(), self.get_input_data(min(index, num)))
 
     def cook(self):
         """
         The entry of the node evaluation.
         Most time we need to call this method instead of AutoNode.run'.
         """
 
-        _tmp = self.autoCook
-        self.model.set_property('autoCook', False)
+        _tmp = self.auto_cook
+        self.model.set_property('auto_cook', False)
 
         if self._error:
             self._close_error()
@@ -184,12 +183,12 @@ def cook(self):
         except:
             self.error(traceback.format_exc())
 
-        self.model.set_property('autoCook', _tmp)
+        self.model.set_property('auto_cook', _tmp)
 
         if self._error:
             return
 
-        self.cookTime = time.time() - _start_time
+        self.cook_time = time.time() - _start_time
 
         self.cooked.emit()
 
@@ -201,19 +200,19 @@ def run(self):
         pass
 
     def on_input_connected(self, to_port, from_port):
-        if self.checkPortType(to_port, from_port):
+        if self.check_port_type(to_port, from_port):
             self.update_stream()
         else:
-            self._needCook = False
+            self.get_input_data = False
             to_port.disconnect_from(from_port)
 
     def on_input_disconnected(self, to_port, from_port):
-        if not self._needCook:
-            self._needCook = True
+        if not self.get_input_data:
+            self.get_input_data = True
             return
         self.update_stream()
 
-    def checkPortType(self, to_port, from_port):
+    def check_port_type(self, to_port, from_port):
         """
         Check whether the port_type of the to_port and from_type is matched.
 
@@ -272,13 +271,6 @@ def set_port_type(self, port, data_type: str):
             conn_type = 'multi' if current_port.multi_connection() else 'single'
             current_port.view.setToolTip('{}: {} ({}) '.format(current_port.name(), data_type, conn_type))
 
-    def create_property(self, name, value, items=None, range=None,
-                        widget_type=NODE_PROP, tab=None, ext=None, funcs=None):
-        super(AutoNode, self).create_property(name, value, items, range, widget_type, tab, ext, funcs)
-
-        if value is not None:
-            self.set_port_type(name, type(value).__name__)
-
     def add_input(self, name='input', data_type='None', multi_input=False, display_name=True,
                   color=None):
         new_port = super(AutoNode, self).add_input(name, multi_input, display_name, color)
@@ -314,23 +306,6 @@ def _close_error(self):
         self.set_property('color', self.get_property('default_color'))
         self._update_tool_tip()
 
-    def _show_error(self, message):
-        """
-        Show the node error.
-        It will change the node color and set error describe to the node tooltip.
-
-        Args:
-            message(str): the describe of the error.
-        """
-
-        if not self._error:
-            self.model.set_property('default_color', self.get_property('color'))
-
-        self._error = True
-        self.set_property('color', self.errorColor)
-        tooltip = '<font color="red"><br>({})</br></font>'.format(message)
-        self._update_tool_tip(tooltip)
-
     def _update_tool_tip(self, message=None):
         """
         Update the node tooltip.
@@ -340,7 +315,7 @@ def _update_tool_tip(self, message=None):
         """
 
         if message is None:
-            tooltip = self._toolTip.format(self._cookTime)
+            tooltip = self._toolTip.format(self._cook_time)
         else:
             tooltip = '<b>{}</b>'.format(self.name())
             tooltip += message
@@ -358,14 +333,21 @@ def _setup_tool_tip(self):
         tooltip = '<br> last cook used: {}s</br>'
         return self._update_tool_tip(tooltip)
 
-    def error(self, message=None):
+    def error(self, message):
         """
-        Set error message to node tooltip.
+        Change the node color and set error describe to the node tooltip.
 
         Args:
             message(str): the describe of the error.
         """
-        self._show_error(message)
+
+        if not self._error:
+            self.model.set_property('default_color', self.get_property('color'))
+
+        self._error = True
+        self.set_property('color', self.errorColor)
+        tooltip = '<font color="red"><br>({})</br></font>'.format(message)
+        self._update_tool_tip(tooltip)
 
     # def __del__(self):
     #     """

example_auto_nodes/node_base/module_node.py

@@ -115,7 +115,7 @@ def run(self):
         for port in self.input_ports():
             if not port.visible():
                 continue
-            data = self.getInputData(port)
+            data = self.get_input_data(port)
             if data is not None:
                 args.append(data)
             elif self.defaultValue is not None:

example_auto_nodes/node_base/subgraph_node.py

@@ -125,14 +125,14 @@ def remove_child(self, node):
             if node in self.sub_graph_output_nodes:
                 self.sub_graph_output_nodes.remove(node)
 
-    def getData(self, port):
+    def get_data(self, port):
         if self.disabled():
-            return super(SubGraphNode, self).getData(port)
+            return super(SubGraphNode, self).get_data(port)
 
         index = int(port.name()[-1])
         for node in self.sub_graph_output_nodes:
             if node.get_property('output index') == index:
-                return node.getData(None)
+                return node.get_data(None)
         self.error('can\'t find matched index output node !!!')
         return self.defaultValue
 
@@ -365,12 +365,12 @@ def __init__(self, defaultInputType=None, defaultOutputType=None):
         self.add_output('out')
         self.add_int_input('input index', 'input index', value=0)
 
-    def getData(self, port):
+    def get_data(self, port):
         parent = self.parent()
         if parent is not None:
             from_port = self.get_parent_port(parent)
             if from_port:
-                return from_port.node().getData(from_port)
+                return from_port.node().get_data(from_port)
             else:
                 # can not find port
                 return self.defaultValue
@@ -404,14 +404,14 @@ def __init__(self, defaultInputType=None, defaultOutputType=None):
         self.add_input('in')
         self.add_int_input('output index', 'output index', value=0)
 
-    def getData(self, port=None):
+    def get_data(self, port=None):
         to_port = self.input(0)
         from_ports = to_port.connected_ports()
         if not from_ports:
             return self.defaultValue
 
         for from_port in from_ports:
-            return from_port.node().getData(from_port)
+            return from_port.node().get_data(from_port)
 
 
 class RootNode(SubGraphNode):