def create_new_element(self, title = None):
self.title = title
if title is None:
self.element_model = ElementModel(class_name = self.class_name)
else:
self.element_model = ElementModel(class_name = self.class_name, title = title)
self.element_model.save()
class Element(object):
class_name = "element"
def __init__(self, title = None, element_model = None):
self.input_connectors = []
self.output_connectors = []
self.flow_control = self.add_input_connector(title = "flow_control", default_value = True)
self.flow = None
self.element_group = None
self.number_of_runs = 0
if element_model is None:
self.create_new_element(title)
else:
self.load_element_from_database(element_model = element_model)
def create_new_element(self, title = None):
self.title = title
if title is None:
self.element_model = ElementModel(class_name = self.class_name)
else:
self.element_model = ElementModel(class_name = self.class_name, title = title)
self.element_model.save()
def set_flow(self, flow):
self.flow = flow
self.element_model.flow = flow.flow_model
self.element_model.save()
def set_element_group(self, element_group):
self.element_group = element_group
self.element_model.group = element_group.element_group_model
self.element_model.save()
def load_element_from_database(self, element_model = None):
self.element_model = element_model
self.title = self.element_model.title
def find_and_set_group_update_grouplist(self, element_groups):
if self.element_model.group is None:
return
for element_group in element_groups:
if element_group.element_group_model == self.element_model.group:
element_group.add_element(self)
return
element_group = ElementGroup(element_group_model = self.element_model.group)
element_group.add_element(self)
element_groups.append(element_group)
return
def delete(self):
self.element_model.delete()
def debug_state(self):
print " -- Element : %s : %s --" % (self.__class__.__name__, self.title)
print " number_of_runs =", self.number_of_runs
print " is_ready ?", self.is_ready()
print " is_blocked ?", self.is_blocked()
print " is_done ?", self.is_done()
for input_connector in self.input_connectors:
print " input_connector :", input_connector.debug_string()
for output_connector in self.output_connectors:
print " output_connector :", output_connector.debug_string()
print " -- --"
@classmethod
def get_all_saved_elements(cls):
return ElementModel.objects.all()
def add_input_connector(self, **kwargs):
input_connector = Connector(element = self, **kwargs)
self.input_connectors.append(input_connector)
return input_connector
def add_output_connector(self, **kwargs):
output_connector = Connector(element = self, **kwargs)
self.output_connectors.append(output_connector)
return output_connector
def replace_input_connector(self, old_input_connector, new_input_connector):
self.input_connectors.remove(old_input_connector)
self.input_connectors.append(new_input_connector)
return new_input_connector
def replace_output_connector(self, old_output_connector, new_output_connector):
self.output_connectors.remove(old_output_connector)
self.output_connectors.append(new_output_connector)
return new_output_connector
def get_connector(self, connector_title):
for connector in self.input_connectors:
if connector.title == connector_title:
return connector
for connector in self.output_connectors:
if connector.title == connector_title:
return connector
return None
def invalidate_element(self, invalid_connector):
# This function only invalidates output connectors of this element. If you
# want to invalidate the full chain behind a connector, use:
# self.flow.invalidate_chain(connector)
#
# invalidate all output connectors if one input connector changes
# only report output connectors that were valid previously!
if DEBUG:
print "%s %s invalidate" % (self.__class__.__name__, self.title)
result = []
if not(invalid_connector in self.input_connectors):
return result
for output_connector in self.output_connectors:
if output_connector.is_ready():
output_connector.invalidate_connector()
result.append(output_connector)
return result
def run_or_block(self, debug = False):
if self.is_blocked():
self.block()
else:
self.number_of_runs += 1
if DEBUG or debug:
print "%s %s run (# %d)" % (self.__class__.__name__, self.title, self.number_of_runs)
self.run(debug = debug)
def block(self):
for output_connector in self.output_connectors:
output_connector.block()
def is_ready(self):
for input_connector in self.input_connectors:
if not(input_connector.is_ready()):
return False
return True
def is_done(self):
for output_connector in self.output_connectors:
if not(output_connector.is_ready()):
return False
return True
def is_blocked(self):
if self.flow_control.value == False:
return True
for input_connector in self.input_connectors:
if input_connector.is_blocked():
return True
return False
def get_number_of_executions(self):
return self.number_of_runs
