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)