def load_burst_entity(self, json_burst, project_id):
"""
Load BurstConfiguration from JSON (possibly exported from a different machine).
Nothing gets persisted in DB or on disk.
:param json_burst: Burst JSON export
:param project_id: Current project ID (it will be used if the user later starts this simulation)
:return: BurstConfiguration filled from JSON
"""
burst_information = BurstInformation.load_from_dict(json_burst)
burst_entity = model.BurstConfiguration(project_id)
burst_entity.from_dict(burst_information.data)
burst_entity.prepare_after_load()
burst_entity.reset_tabs()
workflow_info = burst_information.get_workflows()[0]
workflow_entity = model.Workflow(project_id, None)
workflow_entity.from_dict(workflow_info.data)
view_steps = workflow_info.get_view_steps()
analyze_steps = workflow_info.get_workflow_steps()
for view_step in view_steps:
try:
algorithm = view_step.get_algorithm()
portlet = view_step.get_portlet()
view_step_entity = model.WorkflowStepView(algorithm.id, portlet_id=portlet.id)
view_step_entity.from_dict(view_step.data)
view_step_entity.workflow = workflow_entity
## For each visualize step, also load all of the analyze steps.
analyzers = []
for an_step in analyze_steps:
if (an_step.data["tab_index"] != view_step_entity.tab_index
or an_step.data["index_in_tab"] != view_step_entity.index_in_tab):
continue
algorithm = an_step.get_algorithm()
wf_step_entity = model.WorkflowStep(algorithm.id)
wf_step_entity.from_dict(an_step.data)
wf_step_entity.workflow = workflow_entity
analyzers.append(wf_step_entity)
portlet = PortletConfiguration(portlet.id)
portlet.set_visualizer(view_step_entity)
portlet.set_analyzers(analyzers)
burst_entity.set_portlet(view_step_entity.tab_index, view_step_entity.index_in_tab, portlet)
except Exception:
# only log exception and ignore this step from loading
self.logger.exception("Could not restore Workflow Step " + view_step.get_algorithm().name)
return burst_entity
def __populate_tabs_from_workflow(burst_entity, workflow):
"""
Given a burst and a workflow populate the tabs of the burst with the PortletConfigurations
generated from the steps of the workflow.
"""
visualizers = dao.get_visualization_steps(workflow.id)
for entry in visualizers:
## For each visualize step, also load all of the analyze steps.
portlet_cfg = PortletConfiguration(entry.fk_portlet)
portlet_cfg.set_visualizer(entry)
analyzers = dao.get_workflow_steps_for_position(entry.fk_workflow, entry.tab_index, entry.index_in_tab)
portlet_cfg.set_analyzers(analyzers)
burst_entity.tabs[entry.tab_index].portlets[entry.index_in_tab] = portlet_cfg
return burst_entity
def load_burst_entity(self, json_burst, project_id):
"""
Load BurstConfiguration from JSON (possibly exported from a different machine).
Nothing gets persisted in DB or on disk.
:param json_burst: Burst JSON export
:param project_id: Current project ID (it will be used if the user later starts this simulation)
:return: BurstConfiguration filled from JSON
"""
burst_information = BurstInformation.load_from_dict(json_burst)
burst_entity = model.BurstConfiguration(project_id)
burst_entity.from_dict(burst_information.data)
burst_entity.prepare_after_load()
burst_entity.reset_tabs()
workflow_info = burst_information.get_workflows()[0]
workflow_entity = model.Workflow(project_id, None)
workflow_entity.from_dict(workflow_info.data)
view_steps = workflow_info.get_view_steps()
analyze_steps = workflow_info.get_workflow_steps()
for view_step in view_steps:
try:
algorithm = view_step.get_algorithm()
portlet = view_step.get_portlet()
view_step_entity = model.WorkflowStepView(
algorithm.id, portlet_id=portlet.id)
view_step_entity.from_dict(view_step.data)
view_step_entity.workflow = workflow_entity
## For each visualize step, also load all of the analyze steps.
analyzers = []
for an_step in analyze_steps:
if (an_step.data["tab_index"] != view_step_entity.tab_index
or an_step.data["index_in_tab"] !=
view_step_entity.index_in_tab):
continue
algorithm = an_step.get_algorithm()
wf_step_entity = model.WorkflowStep(algorithm.id)
wf_step_entity.from_dict(an_step.data)
wf_step_entity.workflow = workflow_entity
analyzers.append(wf_step_entity)
portlet = PortletConfiguration(portlet.id)
portlet.set_visualizer(view_step_entity)
portlet.set_analyzers(analyzers)
burst_entity.set_portlet(view_step_entity.tab_index,
view_step_entity.index_in_tab,
portlet)
except Exception:
# only log exception and ignore this step from loading
self.logger.exception("Could not restore Workflow Step " +
view_step.get_algorithm().name)
return burst_entity
def __populate_tabs_from_workflow(burst_entity, workflow):
"""
Given a burst and a workflow populate the tabs of the burst with the PortletConfigurations
generated from the steps of the workflow.
"""
visualizers = dao.get_visualization_steps(workflow.id)
for entry in visualizers:
## For each visualize step, also load all of the analyze steps.
portlet_cfg = PortletConfiguration(entry.fk_portlet)
portlet_cfg.set_visualizer(entry)
analyzers = dao.get_workflow_steps_for_position(entry.fk_workflow, entry.tab_index, entry.index_in_tab)
portlet_cfg.set_analyzers(analyzers)
burst_entity.tabs[entry.tab_index].portlets[entry.index_in_tab] = portlet_cfg
return burst_entity
def create_new_portlet_configuration(self, name=''):
"""
Create a PortletConfiguration entity with the default values from the portlet
XML declaration and the adapter input trees.
"""
chain_adapters = self.reader.get_adapters_chain(self.algo_identifier)
analyze_steps = []
view_step = None
idx = 0
for adapter_declaration in chain_adapters:
adapter_instance = self.build_adapter_from_declaration(adapter_declaration)
alg_inputs = adapter_instance.flaten_input_interface()
###################################################################
### Get the overwrites defined in the portlet configuration #######
### for this specific adapter in the adapter chain #######
### split in static and dynamic ones #######
prepared_params = {KEY_STATIC: {}, KEY_DYNAMIC: {}}
all_portlet_defined_params = self.reader.get_inputs(self.algo_identifier)
specific_adapter_overwrites = [entry for entry in all_portlet_defined_params
if ATT_OVERWRITE in entry and entry[ATT_OVERWRITE] ==
adapter_declaration[ABCAdapter.KEY_NAME]]
for entry in specific_adapter_overwrites:
if ABCAdapter.KEY_DEFAULT in entry:
declared_value = entry[ABCAdapter.KEY_DEFAULT]
elif ABCAdapter.KEY_VALUE in entry:
declared_value = entry[ABCAdapter.KEY_VALUE]
else:
declared_value = ''
if entry[ABCAdapter.KEY_TYPE] == KEY_DYNAMIC:
prepared_params[KEY_DYNAMIC][entry[ABCAdapter.KEY_NAME]] = declared_value
else:
prepared_params[KEY_STATIC][entry[ABCAdapter.KEY_NAME]] = declared_value
###################################################################
### Now just fill the rest of the adapter inputs if they are not ##
### present in neither dynamic or static overwrites. In case of ##
### sub-algorithms also add as static the algorithm : value pair ##
for input_dict in alg_inputs:
input_name = input_dict[ABCAdapter.KEY_NAME]
if input_name not in prepared_params[KEY_STATIC] and input_name not in prepared_params[KEY_DYNAMIC]:
if ABCAdapter.KEY_DEFAULT in input_dict:
input_value = input_dict[ABCAdapter.KEY_DEFAULT]
else:
input_value = ''
prepared_params[KEY_STATIC][input_name] = input_value
###################################################################
### Now parse the dynamic inputs declared in the portlets XML ######
### into workflow_step specific format. ####
for param_name in prepared_params[KEY_DYNAMIC]:
new_value = self._portlet_dynamic2workflow_step(prepared_params[KEY_DYNAMIC][param_name])
prepared_params[KEY_DYNAMIC][param_name] = new_value
###################################################################
algo_id = adapter_instance.stored_adapter.id
if idx == len(chain_adapters) - 1:
view_step = WorkflowStepView(algorithm_id=algo_id, portlet_id=self.portlet_id,
ui_name=name, static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC])
else:
workflow_step = WorkflowStep(algorithm_id=algo_id, static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC])
analyze_steps.append(workflow_step)
idx += 1
portlet_configuration = PortletConfiguration(self.portlet_id)
portlet_configuration.set_analyzers(analyze_steps)
portlet_configuration.set_visualizer(view_step)
return portlet_configuration
def create_new_portlet_configuration(self, name=''):
"""
Create a PortletConfiguration entity with the default values from the portlet
XML declaration and the adapter input trees.
"""
chain_adapters = self.reader.get_adapters_chain(self.algo_identifier)
analyze_steps = []
view_step = None
idx = 0
for adapter_declaration in chain_adapters:
adapter_instance = self.build_adapter_from_declaration(
adapter_declaration)
alg_inputs = adapter_instance.flaten_input_interface()
###################################################################
### Get the overwrites defined in the portlet configuration #######
### for this specific adapter in the adapter chain #######
### split in static and dynamic ones #######
prepared_params = {KEY_STATIC: {}, KEY_DYNAMIC: {}}
all_portlet_defined_params = self.reader.get_inputs(
self.algo_identifier)
specific_adapter_overwrites = [
entry for entry in all_portlet_defined_params
if ATT_OVERWRITE in entry and entry[ATT_OVERWRITE] ==
adapter_declaration[ABCAdapter.KEY_NAME]
]
for entry in specific_adapter_overwrites:
if ABCAdapter.KEY_DEFAULT in entry:
declared_value = entry[ABCAdapter.KEY_DEFAULT]
elif ABCAdapter.KEY_VALUE in entry:
declared_value = entry[ABCAdapter.KEY_VALUE]
else:
declared_value = ''
if entry[ABCAdapter.KEY_TYPE] == KEY_DYNAMIC:
prepared_params[KEY_DYNAMIC][entry[
ABCAdapter.KEY_NAME]] = declared_value
else:
prepared_params[KEY_STATIC][entry[
ABCAdapter.KEY_NAME]] = declared_value
###################################################################
### Now just fill the rest of the adapter inputs if they are not ##
### present in neither dynamic or static overwrites. In case of ##
### sub-algorithms also add as static the algorithm : value pair ##
for input_dict in alg_inputs:
input_name = input_dict[ABCAdapter.KEY_NAME]
if input_name not in prepared_params[
KEY_STATIC] and input_name not in prepared_params[
KEY_DYNAMIC]:
if ABCAdapter.KEY_DEFAULT in input_dict:
input_value = input_dict[ABCAdapter.KEY_DEFAULT]
else:
input_value = ''
prepared_params[KEY_STATIC][input_name] = input_value
###################################################################
### Now parse the dynamic inputs declared in the portlets XML ######
### into workflow_step specific format. ####
for param_name in prepared_params[KEY_DYNAMIC]:
new_value = self._portlet_dynamic2workflow_step(
prepared_params[KEY_DYNAMIC][param_name])
prepared_params[KEY_DYNAMIC][param_name] = new_value
###################################################################
algo_id = adapter_instance.stored_adapter.id
if idx == len(chain_adapters) - 1:
view_step = WorkflowStepView(
algorithm_id=algo_id,
portlet_id=self.portlet_id,
ui_name=name,
static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC])
else:
workflow_step = WorkflowStep(
algorithm_id=algo_id,
static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC])
analyze_steps.append(workflow_step)
idx += 1
portlet_configuration = PortletConfiguration(self.portlet_id)
portlet_configuration.set_analyzers(analyze_steps)
portlet_configuration.set_visualizer(view_step)
return portlet_configuration
def create_new_portlet_configuration(self, name=""):
"""
Create a PortletConfiguration entity with the default values from the portlet
XML declaration and the adapter input trees.
"""
chain_adapters = self.reader.get_adapters_chain(self.algo_identifier)
analyze_steps = []
view_step = None
idx = 0
for adapter_declaration in chain_adapters:
adapter_instance, algorithm_group = self.build_adapter_from_declaration(adapter_declaration)
### Get the flatten interface for the adapter, and in case of #####
### sub-algorithms also get the pair {algorithm : value} #####
algorithm_field = adapter_declaration[KEY_FIELD]
if algorithm_field:
default_algorithm = adapter_declaration[ABCAdapter.KEY_DEFAULT]
else:
default_algorithm = ""
if default_algorithm:
prefix = InputTreeManager.form_prefix(algorithm_field, None, default_algorithm)
alg_inputs = adapter_instance.tree_manager.flatten(
adapter_instance.xml_reader.get_inputs(default_algorithm), prefix
)
else:
alg_inputs = adapter_instance.flaten_input_interface()
###################################################################
### Get the overwrites defined in the portlet configuration #######
### for this specific adapter in the adapter chain #######
### split in static and dynamic ones #######
prepared_params = {KEY_STATIC: {}, KEY_DYNAMIC: {}}
all_portlet_defined_params = self.reader.get_inputs(self.algo_identifier)
specific_adapter_overwrites = [
entry
for entry in all_portlet_defined_params
if ATT_OVERWRITE in entry and entry[ATT_OVERWRITE] == adapter_declaration[ABCAdapter.KEY_NAME]
]
for entry in specific_adapter_overwrites:
if ABCAdapter.KEY_DEFAULT in entry:
declared_value = entry[ABCAdapter.KEY_DEFAULT]
elif ABCAdapter.KEY_VALUE in entry:
declared_value = entry[ABCAdapter.KEY_VALUE]
else:
declared_value = ""
if entry[ABCAdapter.KEY_TYPE] == KEY_DYNAMIC:
prepared_params[KEY_DYNAMIC][entry[ABCAdapter.KEY_NAME]] = declared_value
else:
prepared_params[KEY_STATIC][entry[ABCAdapter.KEY_NAME]] = declared_value
###################################################################
### Now just fill the rest of the adapter inputs if they are not ##
### present in neither dynamic or static overwrites. In case of ##
### sub-algorithms also add as static the algorithm : value pair ##
for input_dict in alg_inputs:
input_name = input_dict[ABCAdapter.KEY_NAME]
if input_name not in prepared_params[KEY_STATIC] and input_name not in prepared_params[KEY_DYNAMIC]:
if ABCAdapter.KEY_DEFAULT in input_dict:
input_value = input_dict[ABCAdapter.KEY_DEFAULT]
else:
input_value = ""
prepared_params[KEY_STATIC][input_name] = input_value
if default_algorithm:
prepared_params[KEY_STATIC][algorithm_field] = default_algorithm
###################################################################
### Now parse the dynamic inputs declared in the portlets XML ######
### into workflow_step specific format. ####
for param_name in prepared_params[KEY_DYNAMIC]:
new_value = self._portlet_dynamic2workflow_step(prepared_params[KEY_DYNAMIC][param_name])
prepared_params[KEY_DYNAMIC][param_name] = new_value
###################################################################
###Finally get the actual algorithm id from the DB as we need the #
###algorithm id, then build the workflow step given the computed #
###parameter set, then build and return the portlet configuration##
algorithm = dao.get_algorithm_by_group(algorithm_group.id, default_algorithm)
if idx == len(chain_adapters) - 1:
view_step = WorkflowStepView(
algorithm_id=algorithm.id,
portlet_id=self.portlet_id,
ui_name=name,
static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC],
)
else:
workflow_step = WorkflowStep(
algorithm_id=algorithm.id,
static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC],
)
analyze_steps.append(workflow_step)
idx += 1
portlet_configuration = PortletConfiguration(self.portlet_id)
portlet_configuration.set_analyzers(analyze_steps)
portlet_configuration.set_visualizer(view_step)
return portlet_configuration
def create_new_portlet_configuration(self, name=''):
"""
Create a PortletConfiguration entity with the default values from the portlet
XML declaration and the adapter input trees.
"""
chain_adapters = self.reader.get_adapters_chain(self.algo_identifier)
analyze_steps = []
view_step = None
idx = 0
for adapter_declaration in chain_adapters:
adapter_instance, algorithm_group = self.build_adapter_from_declaration(adapter_declaration)
### Get the flatten interface for the adapter, and in case of #####
### sub-algorithms also get the pair {algorithm : value} #####
algorithm_field = adapter_declaration[KEY_FIELD]
if algorithm_field:
default_algorithm = adapter_declaration[ABCAdapter.KEY_DEFAULT]
else:
default_algorithm = ''
if default_algorithm:
prefix = InputTreeManager.form_prefix(algorithm_field, None, default_algorithm)
alg_inputs = adapter_instance.tree_manager.flatten(adapter_instance.xml_reader.get_inputs(default_algorithm), prefix)
else:
alg_inputs = adapter_instance.flaten_input_interface()
###################################################################
### Get the overwrites defined in the portlet configuration #######
### for this specific adapter in the adapter chain #######
### split in static and dynamic ones #######
prepared_params = {KEY_STATIC: {}, KEY_DYNAMIC: {}}
all_portlet_defined_params = self.reader.get_inputs(self.algo_identifier)
specific_adapter_overwrites = [entry for entry in all_portlet_defined_params
if ATT_OVERWRITE in entry and entry[ATT_OVERWRITE] ==
adapter_declaration[ABCAdapter.KEY_NAME]]
for entry in specific_adapter_overwrites:
if ABCAdapter.KEY_DEFAULT in entry:
declared_value = entry[ABCAdapter.KEY_DEFAULT]
elif ABCAdapter.KEY_VALUE in entry:
declared_value = entry[ABCAdapter.KEY_VALUE]
else:
declared_value = ''
if entry[ABCAdapter.KEY_TYPE] == KEY_DYNAMIC:
prepared_params[KEY_DYNAMIC][entry[ABCAdapter.KEY_NAME]] = declared_value
else:
prepared_params[KEY_STATIC][entry[ABCAdapter.KEY_NAME]] = declared_value
###################################################################
### Now just fill the rest of the adapter inputs if they are not ##
### present in neither dynamic or static overwrites. In case of ##
### sub-algorithms also add as static the algorithm : value pair ##
for input_dict in alg_inputs:
input_name = input_dict[ABCAdapter.KEY_NAME]
if input_name not in prepared_params[KEY_STATIC] and input_name not in prepared_params[KEY_DYNAMIC]:
if ABCAdapter.KEY_DEFAULT in input_dict:
input_value = input_dict[ABCAdapter.KEY_DEFAULT]
else:
input_value = ''
prepared_params[KEY_STATIC][input_name] = input_value
if default_algorithm:
prepared_params[KEY_STATIC][algorithm_field] = default_algorithm
###################################################################
### Now parse the dynamic inputs declared in the portlets XML ######
### into workflow_step specific format. ####
for param_name in prepared_params[KEY_DYNAMIC]:
new_value = self._portlet_dynamic2workflow_step(prepared_params[KEY_DYNAMIC][param_name])
prepared_params[KEY_DYNAMIC][param_name] = new_value
###################################################################
###Finally get the actual algorithm id from the DB as we need the #
###algorithm id, then build the workflow step given the computed #
###parameter set, then build and return the portlet configuration##
algorithm = dao.get_algorithm_by_group(algorithm_group.id, default_algorithm)
if idx == len(chain_adapters) - 1:
view_step = WorkflowStepView(algorithm_id=algorithm.id, portlet_id=self.portlet_id,
ui_name=name, static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC])
else:
workflow_step = WorkflowStep(algorithm_id=algorithm.id, static_param=prepared_params[KEY_STATIC],
dynamic_param=prepared_params[KEY_DYNAMIC])
analyze_steps.append(workflow_step)
idx += 1
portlet_configuration = PortletConfiguration(self.portlet_id)
portlet_configuration.set_analyzers(analyze_steps)
portlet_configuration.set_visualizer(view_step)
return portlet_configuration
