def save_params(self, block, received_block):
"""
@param block: GenericBlock
@param received_block: dict
"""
for p_name, p in self.params.iteritems():
# TODO: here invoke validator
try:
raw_val = received_block.get(p_name)
# TODO: add conversion to BlockField class
if p.field_type == FieldType.FLOAT:
val = float(raw_val)
elif p.field_type == FieldType.INT:
val = int(raw_val)
elif p.field_type == FieldType.STR:
val = str(raw_val)
elif p.field_type == FieldType.RAW:
val = raw_val
else:
continue
#val = raw_val
setattr(block, p_name, val)
except:
pass
inputs_dict = received_block.get('bound_inputs')
if inputs_dict:
for _, input_field in self.inputs.iteritems():
key = inputs_dict.get(input_field.name)
if key:
var = ScopeVar.from_key(key)
block.bind_input_var(input_field.name, var)
def duplicate(self):
from os import mkdir
blocks = self.get_blocks(self.get_all_block_uuids())
self.pk = None
self.save()
self.post_init()
mkdir(self.get_data_folder())
mapping = {}
mapping['root'] = 'root'
for (uuid, bl) in blocks:
new_bl = bl.duplicate(self.pk, mapping)
self.store_block(new_bl, new_block=True)
mapping[uuid] = new_bl.uuid
blocks = self.get_blocks(self.get_all_block_uuids())
# we need to fix inputs....
for (uuid, bl) in blocks:
bl.remap_inputs(mapping)
scope = bl.get_scope()
scope.load()
for f_name, f in bl._block_serializer.outputs.iteritems():
scope.register_variable(
ScopeVar(bl.uuid, f_name, f.provided_data_type))
for f_name, f in bl.bound_inputs.iteritems():
scope.register_variable(f)
from workflow.blocks.meta.meta_block import UniformMetaBlock
scope.store()
self.store_block(bl)
def save_params(self, block, received_block):
"""
@param block: GenericBlock
@param received_block: dict
"""
for p_name, p in self.params.iteritems():
# TODO: here invoke validator
try:
raw_val = received_block.get(p_name)
# TODO: add conversion to BlockField class
if p.field_type == FieldType.FLOAT:
val = float(raw_val)
elif p.field_type == FieldType.INT:
val = int(raw_val)
elif p.field_type == FieldType.STR:
val = str(raw_val)
elif p.field_type == FieldType.RAW:
val = raw_val
else:
continue
# val = raw_val
setattr(block, p_name, val)
except:
pass
inputs_dict = received_block.get("bound_inputs")
if inputs_dict:
for _, input_field in self.inputs.iteritems():
key = inputs_dict.get(input_field.name)
if key:
var = ScopeVar.from_key(key)
block.bind_input_var(input_field.name, var)
def register_inner_output_variables(self, inner_outputs_list):
scope = self.get_sub_scope()
scope.load()
for new_inner_output in inner_outputs_list:
self.inner_output_manager.register(new_inner_output)
self._block_serializer.register(new_inner_output)
scope.register_variable(ScopeVar(
self.uuid, new_inner_output.name, new_inner_output.provided_data_type))
scope.store()
def add_collector_var(self, exp, received_block, *args, **kwargs):
rec_new = received_block.get("collector_spec", {}).get("new", {})
if rec_new:
name = str(rec_new.get("name"))
scope_var_key = rec_new.get("scope_var")
data_type = rec_new.get("data_type")
if name and scope_var_key:
scope_var = ScopeVar.from_key(scope_var_key)
scope_var.data_type = data_type
self.collector_spec.register(name, scope_var)
self.update_res_seq_fields()
exp.store_block(self)
self.validate_params(exp, received_block, *args, **kwargs)
def duplicate(self, exp_id, mapping):
import copy
old_uuid = self.uuid
new_obj = copy.deepcopy(self)
new_obj.uuid = "B" + uuid1().hex[:8]
new_obj.exp_id = exp_id
if new_obj.scope_name:
# little hack, it uses the fact that a scope name has a structure root_uuid1_uuid2....
parent_uuids = new_obj.scope_name.split('_')
for parent_uuid in parent_uuids:
new_obj.scope_name = new_obj.scope_name.replace(
parent_uuid, mapping[parent_uuid])
scope = new_obj.get_scope()
scope.load()
for f_name, f in new_obj._block_serializer.outputs.iteritems():
scope.register_variable(
ScopeVar(new_obj.uuid, f_name, f.provided_data_type))
# log.debug("Registering normal outputs: %s", f_name)
# new_obj.register_provided_objects(scope, ScopeVar(new_obj.uuid, f_name, f.provided_data_type))
scope.store()
return new_obj
def __init__(self, exp_id=None, scope_name=None):
"""
Building block for workflow
"""
# TODO: due to dynamic inputs, find better solution
self._block_serializer = BlockSerializer.clone(
self.__class__._block_serializer)
self.state = "created"
self.uuid = "B" + uuid1().hex[:8]
self.exp_id = exp_id
exp = None
if exp_id:
exp = Experiment.get_exp_by_id(exp_id)
self.scope_name = scope_name
self.base_name = ""
# Used only be meta-blocks
self.children_blocks = []
# End
self._out_data = dict()
self.out_manager = OutManager()
self.input_manager = InputManager()
# Automatic execution status map
self.auto_exec_status_ready = set(["ready"])
self.auto_exec_status_done = set(["done"])
self.auto_exec_status_working = set(["working"])
self.auto_exec_status_error = set(["execution_error"])
# Init block fields
for f_name, f in itertools.chain(
self._block_serializer.fields.iteritems(),
self._block_serializer.params.iteritems()):
#if f_name not in self.__dict__ and not f.is_a_property:
if not f.is_a_property and not hasattr(self, f_name):
try:
setattr(self, f_name, f.init_val)
except:
import ipdb
ipdb.set_trace()
for f_name, f in self._block_serializer.inputs.iteritems():
if f.multiply_extensible:
setattr(self, f_name, []) # Names of dynamically added ports
# TODO: Hmm maybe more metaclass magic can be applied here
scope = self.get_scope()
scope.load()
for f_name, f in self._block_serializer.outputs.iteritems():
if exp:
exp.log(self.uuid, "Registering normal outputs: %s" % f_name)
log.debug("Registering normal outputs: %s", f_name)
self.register_provided_objects(
scope, ScopeVar(self.uuid, f_name, f.provided_data_type))
# TODO: Use factories for init values
#if f.init_val is not None:
# setattr(self, f.name, f.init_val)
scope.store()
for f_name, f in self._block_serializer.fields.items():
if f.init_val is not None:
#setattr(self, f.name, f.init_val)
pass
for f_name, f in self._block_serializer.inputs.iteritems():
self.input_manager.register(f)
