PyFlow.Packages.PyFlowBase.Nodes package

Submodules

PyFlow.Packages.PyFlowBase.Nodes.address module

class PyFlow.Packages.PyFlowBase.Nodes.address.address(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.branch module

class PyFlow.Packages.PyFlowBase.Nodes.branch.branch(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.charge module

class PyFlow.Packages.PyFlowBase.Nodes.charge.charge(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.cliexit module

class PyFlow.Packages.PyFlowBase.Nodes.cliexit.cliexit(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.colorRamp module

class PyFlow.Packages.PyFlowBase.Nodes.colorRamp.colorRamp(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.commentNode module

class PyFlow.Packages.PyFlowBase.Nodes.commentNode.commentNode(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

PyFlow.Packages.PyFlowBase.Nodes.compound module

class PyFlow.Packages.PyFlowBase.Nodes.compound.compound(name)

Bases: PyFlow.Core.NodeBase.NodeBase

This node encapsulates a graph, like compound in xsi

pins can be edited only from inside the compound

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

autoAffectPins()

All value inputs affects on all value outputs. All exec inputs affects on all exec outputs

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

kill(*args, **kwargs)

Removes item

Raises:NotImplementedError – If not implemented

onGraphInputPinCreated(outPin)

Reaction when pin added to graphInputs node

Parameters:outPin (PinBase) – output pin on graphInputs node

onGraphOutputPinCreated(inPin)

Reaction when pin added to graphOutputs node

Parameters:inPin (PinBase) – input pin on graphOutputs node

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

setName(name)

Sets item name

Parameters:name (str) – Target name Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.consoleOutput module

class PyFlow.Packages.PyFlowBase.Nodes.consoleOutput.consoleOutput(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.constant module

class PyFlow.Packages.PyFlowBase.Nodes.constant.constant(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.convertTo module

class PyFlow.Packages.PyFlowBase.Nodes.convertTo.convertTo(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.delay module

class PyFlow.Packages.PyFlowBase.Nodes.delay.delay(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.deltaTime module

class PyFlow.Packages.PyFlowBase.Nodes.deltaTime.deltaTime(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.dictKeys module

class PyFlow.Packages.PyFlowBase.Nodes.dictKeys.dictKeys(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.doN module

class PyFlow.Packages.PyFlowBase.Nodes.doN.doN(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.doOnce module

class PyFlow.Packages.PyFlowBase.Nodes.doOnce.doOnce(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.flipFlop module

class PyFlow.Packages.PyFlowBase.Nodes.flipFlop.flipFlop(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.floatRamp module

class PyFlow.Packages.PyFlowBase.Nodes.floatRamp.floatRamp(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.forEachLoop module

class PyFlow.Packages.PyFlowBase.Nodes.forEachLoop.forEachLoop(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.forLoop module

class PyFlow.Packages.PyFlowBase.Nodes.forLoop.forLoop(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.forLoopBegin module

class PyFlow.Packages.PyFlowBase.Nodes.forLoopBegin.forLoopBegin(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.forLoopWithBreak module

class PyFlow.Packages.PyFlowBase.Nodes.forLoopWithBreak.forLoopWithBreak(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.getVar module

class PyFlow.Packages.PyFlowBase.Nodes.getVar.getVar(name, var=None)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name, var=None)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.graphNodes module

class PyFlow.Packages.PyFlowBase.Nodes.graphNodes.graphInputs(name)

Bases: PyFlow.Core.NodeBase.NodeBase

Represents a group of input pins on compound node

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

getUniqPinName(name)

Returns unique name for pin

Parameters:name (str) – Target pin name Return type:str

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

class PyFlow.Packages.PyFlowBase.Nodes.graphNodes.graphOutputs(name)

Bases: PyFlow.Core.NodeBase.NodeBase

Represents a group of output pins on compound node

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

getUniqPinName(name)

Returns unique name for pin

Parameters:name (str) – Target pin name Return type:str

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

PyFlow.Packages.PyFlowBase.Nodes.imageDisplay module

class PyFlow.Packages.PyFlowBase.Nodes.imageDisplay.imageDisplay(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.loopEnd module

class PyFlow.Packages.PyFlowBase.Nodes.loopEnd.loopEnd(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.makeAnyDict module

class PyFlow.Packages.PyFlowBase.Nodes.makeAnyDict.makeAnyDict(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.makeArray module

class PyFlow.Packages.PyFlowBase.Nodes.makeArray.makeArray(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.makeDict module

class PyFlow.Packages.PyFlowBase.Nodes.makeDict.makeDict(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonData)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

PyFlow.Packages.PyFlowBase.Nodes.makeDictElement module

class PyFlow.Packages.PyFlowBase.Nodes.makeDictElement.makeDictElement(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.makeList module

class PyFlow.Packages.PyFlowBase.Nodes.makeList.makeList(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.pythonNode module

class PyFlow.Packages.PyFlowBase.Nodes.pythonNode.pythonNode(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.reroute module

class PyFlow.Packages.PyFlowBase.Nodes.reroute.reroute(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.rerouteExecs module

class PyFlow.Packages.PyFlowBase.Nodes.rerouteExecs.rerouteExecs(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

PyFlow.Packages.PyFlowBase.Nodes.retriggerableDelay module

class PyFlow.Packages.PyFlowBase.Nodes.retriggerableDelay.retriggerableDelay(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.sequence module

class PyFlow.Packages.PyFlowBase.Nodes.sequence.sequence(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

createOutputPin(*args, **kwargs)

Creates output pin

Parameters:

• pinName (str) – Pin name
• dataType (str) – Pin data type
• defaultValue (object) – Pin default value
• structure (Single) – Pin structure
• constraint (object) – Pin constraint. Should be any hashable type. We use str
• structConstraint (object) – Pin struct constraint. Also should be hashable type
• supportedPinDataTypes (list(str)) – List of allowed pin data types to be connected. Used by AnyPin
• group (str) – Pin group. Used only by ui wrapper

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.setVar module

class PyFlow.Packages.PyFlowBase.Nodes.setVar.setVar(name, var=None)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name, var=None)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

postCreate(jsonTemplate=None)

Called after node was added to graph

Parameters:jsonTemplate (dict or None) – Serialized data of spawned node

serialize()

Implements how item will be serialized

Raises:NotImplementedError – If not implemented

PyFlow.Packages.PyFlowBase.Nodes.stickyNote module

class PyFlow.Packages.PyFlowBase.Nodes.stickyNote.stickyNote(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

PyFlow.Packages.PyFlowBase.Nodes.stringToArray module

class PyFlow.Packages.PyFlowBase.Nodes.stringToArray.stringToArray(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.switchOnString module

class PyFlow.Packages.PyFlowBase.Nodes.switchOnString.switchOnString(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

PyFlow.Packages.PyFlowBase.Nodes.tick module

class PyFlow.Packages.PyFlowBase.Nodes.tick.tick(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

PyFlow.Packages.PyFlowBase.Nodes.timer module

class PyFlow.Packages.PyFlowBase.Nodes.timer.timer(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

PyFlow.Packages.PyFlowBase.Nodes.whileLoop module

class PyFlow.Packages.PyFlowBase.Nodes.whileLoop.whileLoop(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

PyFlow.Packages.PyFlowBase.Nodes.whileLoopBegin module

class PyFlow.Packages.PyFlowBase.Nodes.whileLoopBegin.whileLoopBegin(name)

Bases: PyFlow.Core.NodeBase.NodeBase

__init__(name)

Initialize self. See help(type(self)) for accurate signature.

compute(*args, **kwargs)

This is node’s brains. Main logic goes here

Here are basic steps:

1. Get data from input pins
2. Do stuff
3. Set data to output pins
4. Call execs if needed

Here is compute method of charge node

def compute(self, *args, **kwargs):
    step = abs(self.step.getData())
    if (self._currentAmount + step) < abs(self.amount.getData()):
        self._currentAmount += step
        return
    self.completed.call(*args, **kwargs)
    self._currentAmount = 0.0

Note

See PyFlow.Packages.PyFlowBase.Nodes source code module for more examples

Module contents