"""

del NODECLASSES[cls.__name__]

"""

def __init__(self, name, varType, hints=None, default='', select=None, owner=False, list=False, optional=False):

self.name = name

self.connected = False

self.varType = varType

self.optional = optional

if not hints:

self.hints = [varType.__name__]

else:

self.hints = [varType.__name__] + hints

self.default = default

self.valueSet = False

self.value = None

self.select = select

self.owner = owner

self.list = list

self.loopLevel = 0

self.usedDefault = False

self.pure = 0

def setOwner(self, owner):

self.owner = owner

def setDefault(self, value):

if not self.varType == object and not issubclass(self.varType, Type):

try:

self.default = self.varType(value)

except ValueError:

self.default = ''

if self.varType == bool:

try:

if value.upper() == 'TRUE':

self.default = True

else:

self.default = False

except:

self.default = value

else:

self.default = value

def __str__(self):

return 'INFO'

def reset(self, nodeLoopLevel=0, force=False):

if nodeLoopLevel > self.loopLevel and not force:

# print('Not resetting Input {} because owing node has higher node\n'

# 'level than the node setting the Input: {}vs.{}'.format(self.name, nodeLoopLevel, self.loopLevel))

return

self.default = None

self.valueSet = False

def __call__(self, noException=False):

if self.valueSet:

if not self.varType == object:

if isinstance(self.varType, MetaType):

if self.list:

return [self.varType.checkType(i) for i in self.value]

return self.varType.checkType(self.value)

else:

if self.list:

return [self.varType(i) for i in self.value]

return self.varType(self.value)

else:

return self.value

elif self.default != None and not self.connected:

self.usedDefault = True if self.loopLevel > 0 else False

if not self.varType == object and self.default:

return self.varType(self.default)

else:

return self.default

else:

if noException:

return None

else:

raise InputNotAvailable('Input not set for node.')

def set(self, value, override=False, loopLevel=0):

if self.valueSet and not override:

raise InputAlreadySet('Input \'{}\' of node \'{}\' is already set.'.format(self.name, str(self.owner)))

self.value = value

self.valueSet = True

if not self.name == 'Control':

self.loopLevel = loopLevel

def setPure(self):

self.pure = 1

def setConnected(self, value: bool):

self.connected = value

def isAvailable(self):

if self.valueSet:

# print('^^^^^^^^^^^^^^^^^^', self.name, self.value, self.valueSet)

return True

elif self.default != None and not self.connected and not self.usedDefault and self.pure < 2:

if self.pure == 1:

self.pure = 2

# self.usedDefault = True

# print('+++++++++++++++++', self.name, self.value, self.valueSet, self.owner, self.usedDefault, self.pure)

return True

def __call__(self, value):

try:

value.__FloppyType__ = self.varType

except AttributeError:

pass

self.value = value

"""

inputs = []

outputs = []

@classmethod

def __prepare__(metacls, name, bases):

MetaNode.inputs = []

MetaNode.outputs = []

MetaNode.tags = []

return {'Input': MetaNode.addInput,

'input': MetaNode.addInput,

'Output': MetaNode.addOutput,

'output': MetaNode.addOutput,

'Tag': MetaNode.addTag,

'tag': MetaNode.addTag}

def addTag(*args):

for arg in args:

MetaNode.tags.append(arg)

def addInput(name: str,

varType: object,

hints=None,

default='',

select=None,

list=False,

optional=False):

MetaNode.inputs.append({'name': name,

'varType': varType,

'hints': hints,

'default': default,

'select': select,

'list': list,

'optional': optional})

def addOutput(name: str,

varType: object,

hints=None,

default='',

select=None,

list=False):

MetaNode.outputs.append({'name': name,

'varType': varType,

'hints': hints,

'default': default,

'select': select,

'list': list})

def __new__(cls, name, bases, classdict):

result = type.__new__(cls, name, bases, classdict)

# result.__dict__['Input'] = result._addInput

NODECLASSES[name] = result

try:

result.__inputs__ = result.__bases__[0].__inputs__.copy()

except AttributeError:

result.__inputs__ = OrderedDict()

try:

result.__outputs__ = result.__bases__[0].__outputs__.copy()

except AttributeError:

result.__outputs__ = OrderedDict()

try:

result.__tags__ = result.__bases__[0].__tags__.copy()

except AttributeError:

result.__tags__ = []

for inp in MetaNode.inputs:

result._addInput(data=inp, cls=result)

for out in MetaNode.outputs:

result._addOutput(data=out, cls=result)

for tag in MetaNode.tags:

result._addTag(tag)

"""

Input('TRIGGER', object, optional=True)

Tag('Node')

def __init__(self, nodeID, graph):

self.loopLevel = 0

self.__pos__ = (0, 0)

self.graph = graph

self.locked = False

self.subgraph = 'main'

self.ID = nodeID

self.buffered = False

self.inputs = OrderedDict()

self.outputs = OrderedDict()

self.outputBuffer = {}

self.inputPins = OrderedDict()

self.outputPins = OrderedDict()

for i, inp in enumerate(self.__inputs__.values()):

inp = copy(inp)

inp.setOwner(self)

inpID = '{}:I{}'.format(self.ID, inp.name)

newPin = Pin(inpID, inp, self)

self.inputPins[inp.name] = newPin

self.inputs[inp.name] = inp

for i, out in enumerate(self.__outputs__.values()):

out = copy(out)

out.setOwner(self)

outID = '{}:O{}'.format(self.ID, out.name)

newPin = Pin(outID, out, self)

self.outputPins[out.name] = newPin

self.outputs[out.name] = out

self.outputBuffer[out.name] = None

if not self.inputs.keys():

raise AttributeError('Nodes without any input are not valid.')

if len(self.inputs.keys()) == 2:

self.inputs[list(self.inputs.keys())[1]].setPure()

self.setup()

def setup(self):

"""

pass

def __str__(self):

return '{}-{}'.format(self.__class__.__name__, self.ID)

def __hash__(self):

return hash(str(self))

def lock(self):

self.locked = True

def unlock(self):

self.locked = False

self.graph.runningNodes.remove(self.ID)

def run(self) -> None:

"""

print('Executing node {}'.format(self))

# print('===============\nExecuting node {}'.format(self))

# print('{} is loopLevel ='.format(str(self)), self.loopLevel,'\n================')

def notify(self):

"""

for con in self.graph.getConnectionsFrom(self):

self.buffered = False

outputName = con['outputName']

nextNode = con['inputNode']

nextInput = con['inputName']

# nextNode.prepare()

if self.outputs[outputName].valueSet:

nextNode.setInput(nextInput, self.outputs[outputName].value, override=True, loopLevel=self.loopLevel)

else:

nextNode.setInput(nextInput, self.outputs[outputName].default, override=True, loopLevel=self.loopLevel)

if not self.graph.getConnectionsFrom(self):

self.buffered = True

for out in self.outputs.values():

self.outputBuffer[out.name] = out.value

[Info.reset(inp, self.loopLevel) for inp in self.inputs.values()]

def setInput(self, inputName, value, override=False, loopLevel=False):

"""

self.loopLevel = max([self.loopLevel, loopLevel])

self.inputs[inputName].set(value, override=override, loopLevel=loopLevel)

# print('%%%%%%%%%%%%%%%%', str(self), inputName, value)

def check(self) -> bool:

"""

if self.locked:

return False

if self.buffered and self.outputs.keys():

print('Node {} has buffered output. Trying to notify outgoing connections.'.format(self))

return self.notify()

for inp in self.inputs.values():

if not inp.isAvailable():

if inp.optional and not inp.connected:

continue

# print(' {}: Prerequisites not met.'.format(str(self)))

return False

# print(' {}: ready.'.format(str(self)))

return True

def report(self):

"""

return {'template': 'DefaultTemplate',

'class': self.__class__.__name__,

'ID': self.ID,

'inputs': [(i, v.varType.__name__, str(v.value) if len(str(v.value)) < 10 else str(v.value)[:10]+'...') for i, v in self.inputs.items()],

'outputs': [(i, v.varType.__name__, str(v.value) if len(str(v.value)) < 10 else str(v.value)[:10]+'...') for i, v in self.outputs.items()],

'keep': None}

# def prepare(self):

# """

# Method for preparing a node for execution.

# This method is called on each node before the main execution loop of the owning graph instance is started.

# The methods makes sure that artifacts from previous execution are reset to their original states and default

# values of inputs that are connected to other nodes' outputs are removed.

# :return:

# """

# return

# [InputInfo.reset(inp) for inp in self.inputs.values()]

def _addInput(*args, data='', cls=None):

"""

inputInfo = InputInfo(**data)

cls.__inputs__[data['name']] = inputInfo

def _addOutput(*args, data='', cls=None):

"""

outputInfo = OutputInfo(**data)

cls.__outputs__[data['name']] = outputInfo

@classmethod

def _addTag(cls, tag='Node'):

"""

cls.__tags__.append(tag)

def __getattr__(self, item):

"""

if item.startswith('_') and not item.startswith('__'):

try:

return self.inputs[item.lstrip('_')]()

except KeyError:

try:

return self.outputs[item.lstrip('_')]

except KeyError:

raise AttributeError('No I/O with name {} defined.'.format(item.lstrip('_')))

# raise AttributeError('No Input with name {} defined.'.format(item.lstrip('_')))

else:

return super(Node, self).__getattr__(item)

def getInputPin(self, inputName):

"""

return self.inputPins[inputName]

def getOutputPin(self, outputName):

return self.outputPins[outputName]

def getInputInfo(self, inputName):

return self.inputs[inputName]

def getOutputInfo(self, outputName):

return self.outputs[outputName]

def getInputID(self, inputName):

return '{}:I{}'.format(self.ID, inputName)

def getOutputID(self, outputName):

return '{}:O{}'.format(self.ID, outputName)

def getInputofType(self, varType):

for inp in self.inputs.values():

if issubclass(varType, inp.varType) or issubclass(inp.varType, varType):

return inp

def getOutputofType(self, varType):

for out in self.outputs.values():

if issubclass(varType, out.varType) or issubclass(out.varType, varType):

return out

def save(self):

"""

inputConns = [self.graph.getConnectionOfInput(inp) for inp in self.inputs.values()]

# print(inputConns)

inputConns = {inputConn['inputName']: inputConn['outputNode'].getOutputID(inputConn['outputName']) for inputConn in inputConns if inputConn}

outputConns = {out.name: self.graph.getConnectionsOfOutput(out) for out in self.outputs.values()}

for key, conns in outputConns.items():

conns = [outputConn['inputNode'].getInputID(outputConn['inputName']) for outputConn in conns]

outputConns[key] = conns

return {'class': self.__class__.__name__,

'position': self.__pos__,

'inputs': [(inputName, inp.varType.__name__, inp(True), inp.default)

for inputName, inp in self.inputs.items()],

'inputConnections': inputConns,

'outputs': [(outputName, out.varType.__name__, out.value, out.default)

for outputName, out in self.outputs.items()],

'outputConnections': outputConns,

'subgraph': self.subgraph}

@classmethod

def matchHint(cls, text: str):

return cls.matchInputHint(text) or cls.matchOutputHint(text) or cls.matchClassTag(text)

@classmethod

def matchClassTag(cls, text: str):

return any([tag.lower().startswith(text) for tag in cls.__tags__])

@classmethod

def matchInputHint(cls, text: str):

if text == 'object':

return True

if any([any([hint.startswith(text) for hint in inp.hints]) for inp in cls.__inputs__.values()]):

return True

@classmethod

def matchOutputHint(cls, text: str):

if text == 'object':

return True

if any([any([hint.startswith(text) for hint in out.hints]) for out in cls.__outputs__.values()]):

"""

def __init__(self, pinID, info, node):

self.ID = pinID

self.ID = pinID

self.name = info.name

self.info = info

info.ID = pinID

"""

def addProxyInput(self, name, output, input, varType):

pass

def addProxyOutput(self, name, output, input, varType):

"""

Input('Start', object)

Input('Control', object)

Output('Final', object)

def __init__(self, *args, **kwargs):

super(ControlNode, self).__init__(*args, **kwargs)

"""

Input('Switch', bool)

Output('True', object)

Output('False', object)

Tag('If')

Tag('Else')

def __init__(self, *args, **kwargs):

super(Switch, self).__init__(*args, **kwargs)

self.fresh = True

def check(self):

if self.fresh:

for inp in self.inputs.values():

if inp.name == 'Control':

continue

if not inp.isAvailable():

# print(' {}: Prerequisites not met.'.format(str(self)))

return False

return True

else:

if self.inputs['Control'].isAvailable():

return True

def run(self):

print('Executing node {}'.format(self))

if self.fresh:

if self._Switch:

self._True(self._Start)

else:

self._False(self._Start)

else:

self._Final(self._Control)

def notify(self):

if self.fresh:

output = self.outputs['True'] if self._Switch else self.outputs['False']

for con in self.graph.getConnectionsOfOutput(output):

outputName = con['outputName']

nextNode = con['inputNode']

nextInput = con['inputName']

nextNode.setInput(nextInput, self.outputs[outputName].value)

self.fresh = False

self.inputs['Start'].reset()

self.inputs['Switch'].reset()

else:

output = self.outputs['Final']

for con in self.graph.getConnectionsOfOutput(output):

outputName = con['outputName']

nextNode = con['inputNode']

nextInput = con['inputName']

nextNode.setInput(nextInput, self.outputs[outputName].value)

self.fresh = True

"""

Input('Pass', object)

Input('Wait', object)

Output('Out', object)

def run(self):

self._Out(self._Pass)

def notify(self):

super(WaitAll, self).notify()

"""

def check(self):

for inp in self.inputs.values():

if inp.valueSet:

# print(' {}: Prerequisites not met.'.format(str(self)))

return True

def run(self):

super(WaitAny, self).run()

for inp in self.inputs.values():

if inp.valueSet:

Input('Test', bool)

Output('T', bool)

def run(self):

super(Test, self).run()

print(self._Test)

Input('strInput', str)

Output('strOutput', str)

def run(self):

super(TestNode, self).run()

import time

time.sleep(self.ID/2000.)

self._strOutput('')

# def report(self):

# r = super(TestNode, self).report()

# r['template'] = 'plotTemplate'

Input('strInput', str)

Input('floatInput', float, default=10.)

Input('Input', str, default='TestNode')

"""

Input('Value', bool, select=(True, False))

Output('Boolean', bool)

def run(self):

super(CreateBool, self).run()

"""

Input('Value', int, )

Output('Integer', int)

def run(self):

super(CreateInt, self).run()

"""

Input('Name', str)

Output('Content', str)

def run(self):

super(ReadFile, self).run()

fileName = self._Name

try:

with open(fileName, 'r') as fp:

c = fp.read()

except IOError:

self.raiseError('IOError', 'No file named {}.'.format(fileName))

return 1

Input('Name', str)

Input('Content', str)

Output('Trigger', object)

def run(self):

super(WriteFile, self).run()

with open(self._Name, 'w') as fp:

"""

# Input('Start', object, list=True)

# Output('ListElement', object)

def __init__(self, *args, **kwargs):

super(ForLoop, self).__init__(*args, **kwargs)

self.fresh = True

self.counter = 0

self.done = False

self.loopLevel = 0

def setInput(self, inputName, value, override=False, loopLevel=0):

if inputName == 'Control':

loopLevel = self.loopLevel

super(ForLoop, self).setInput(inputName, value, override, loopLevel)

# print(' XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX')

def check(self):

if self.fresh:

for inp in self.inputs.values():

if inp.name == 'Control':

continue

if not inp.isAvailable():

# print(' {}: Prerequisites not met.'.format(str(self)))

return False

return True

else:

if self.inputs['Control'].isAvailable():

return True

def run(self):

super(ForLoop, self).run()

self.fresh = False

try:

self._ListElement(self._Start[self.counter])

except IndexError:

self._Final(self._Start)

self.done = True

self.counter += 1

def notify(self):

if not self.done:

for oName in self.outputs.keys():

if oName == 'Final':

continue

output = self.outputs[oName]

for con in self.graph.getConnectionsOfOutput(output):

outputName = con['outputName']

nextNode = con['inputNode']

nextInput = con['inputName']

# nextNode.prepare()

nextNode.setInput(nextInput, self.outputs[outputName].value, override=True, loopLevel=self.loopLevel+1)

self.inputs['Control'].reset(force=True)

else:

output = self.outputs['Final']

for con in self.graph.getConnectionsOfOutput(output):

outputName = con['outputName']

nextNode = con['inputNode']

nextInput = con['inputName']

nextNode.setInput(nextInput, self.outputs[outputName].value, loopLevel=self.loopLevel)

# self.prepare()

self.fresh = True

for inp in self.inputs.values():

if not inp.name == 'Iterations':

inp.reset()

self.counter = 0

self.fresh = True

"""

Input('object1', object)

Input('object2', object)

Output('Equal', bool)

def run(self):

super(IsEqual, self).run()

"""

Input('Str', str)

Output('String', str)

def run(self):

super(CreateString, self).run()

"""

Tag('Debug')

def print(self, *args):

string = ' '.join(args)

"""

Input('Object', object)

Output('Out', object)

def run(self):

super(DebugPrint, self).run()

obj = self._Object

try:

self.print(str(obj.__FloppyType__.debugInfoGetter(obj)()))

except AttributeError:

self.print(str(obj))

Input('Str1', str)

Input('Str2', str)

Output('Joined', str)

def run(self):

super(Join, self).run()

Input('Input', object)

Output('Output', object)

Tag('Loop')

def run(self):