def from_xml(self, spin_nodes, file_version=None): """Recreate a spin list data structure from the XML spin nodes. @param spin_nodes: The spin XML nodes. @type spin_nodes: xml.dom.minicompat.NodeList instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Test if empty. if not self.is_empty(): raise RelaxFromXMLNotEmptyError(self.__class__.__name__) # Loop over the spins. for spin_node in spin_nodes: # Get the spin details and add the spin to the SpinList structure. name = str(spin_node.getAttribute('name')) if name == 'None': name = None num = eval(spin_node.getAttribute('num')) self.add_item(spin_name=name, spin_num=num) # Recreate the current spin container. xml_to_object(spin_node, self[-1], file_version=file_version) # Backwards compatibility transformations. self[-1]._back_compat_hook(file_version)
def from_xml(self, spin_nodes, file_version=None): """Recreate a spin list data structure from the XML spin nodes. @param spin_nodes: The spin XML nodes. @type spin_nodes: xml.dom.minicompat.NodeList instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Test if empty. if not self.is_empty(): raise RelaxFromXMLNotEmptyError(self.__class__.__name__) # Loop over the spins. for spin_node in spin_nodes: # Get the spin details and add the spin to the SpinList structure. name = str(spin_node.getAttribute('name')) if name == 'None': name = None num = eval(spin_node.getAttribute('num')) # Get the spin details and add the spin to the SpinList structure. self.add_item(spin_name=name, spin_num=num) # Recreate the current spin container. xml_to_object(spin_node, self[-1], file_version=file_version) # Backwards compatibility transformations. self[-1]._back_compat_hook(file_version)
def from_xml(self, diff_tensor_node, file_version=1): """Recreate the diffusion tensor data structure from the XML diffusion tensor node. @param diff_tensor_node: The diffusion tensor XML node. @type diff_tensor_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # First set the diffusion type. Doing this first is essential for the proper reconstruction of the object. self.__dict__['type'] = str(diff_tensor_node.getAttribute('type')) # A temporary object to pack the structures from the XML data into. temp_obj = Element() # Recreate all the other data structures (into the temporary object). xml_to_object(diff_tensor_node, temp_obj, file_version=file_version) # Loop over all modifiable objects in the temporary object and make soft copies of them. for name in self._mod_attr: # Skip if missing from the object. if not hasattr(temp_obj, name): continue # The category. if search('_err$', name): category = 'err' param = name.replace('_err', '') elif search('_sim$', name): category = 'sim' param = name.replace('_sim', '') else: category = 'val' param = name # Get the object. value = getattr(temp_obj, name) # Normal parameters. if category == 'val': self.set(param=param, value=value) # Errors. elif category == 'err': self.set(param=param, value=value, category='err') # Simulation objects objects. else: # Recreate the list elements. for i in range(len(value)): self.set(param=param, value=value[i], category='sim', sim_index=i) # Delete the temporary object. del temp_obj
def from_xml(self, mol_node, file_version=1): """Recreate the MolContainer from the XML molecule node. @param mol_node: The molecule XML node. @type mol_node: xml.dom.minicompat.NodeList instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Recreate the current molecule container. xml_to_object(mol_node, self, file_version=file_version)
def from_xml(self, super_node, file_version=1): """Recreate the element data structure from the XML element node. @param super_node: The element XML node. @type super_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Recreate all the other data structures. xml_to_object(super_node, self, file_version=file_version)
def from_xml(self, str_node, dir=None, file_version=1): """Recreate the structural object from the XML structural object node. @param str_node: The structural object XML node. @type str_node: xml.dom.minicompat.Element instance @keyword dir: The name of the directory containing the results file. @type dir: str @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Get the pairs of displacements. pair_nodes = str_node.getElementsByTagName('pair') # Loop over the pairs. for pair_node in pair_nodes: # Get the two models. id_from = str(pair_node.getAttribute('id_from')) id_to = str(pair_node.getAttribute('id_to')) # Initialise structures if necessary. if not id_from in self._translation_vector: self._translation_vector[id_from] = {} if not id_from in self._translation_distance: self._translation_distance[id_from] = {} if not id_from in self._rotation_matrix: self._rotation_matrix[id_from] = {} if not id_from in self._rotation_axis: self._rotation_axis[id_from] = {} if not id_from in self._rotation_angle: self._rotation_angle[id_from] = {} # A temporary container to place the Python objects into. cont = ModelContainer() # Recreate the Python objects. xml_to_object(pair_node, cont, file_version=file_version) # Repackage the data. for name in [ 'translation_vector', 'translation_distance', 'rotation_matrix', 'rotation_axis', 'rotation_angle' ]: # The objects. obj = getattr(self, '_' + name) obj_temp = getattr(cont, name) # Store. obj[id_from][id_to] = obj_temp
def from_xml(self, str_node, dir=None, file_version=1): """Recreate the structural object from the XML structural object node. @param str_node: The structural object XML node. @type str_node: xml.dom.minicompat.Element instance @keyword dir: The name of the directory containing the results file. @type dir: str @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Get the pairs of displacements. pair_nodes = str_node.getElementsByTagName('pair') # Loop over the pairs. for pair_node in pair_nodes: # Get the two models. id_from = str(pair_node.getAttribute('id_from')) id_to = str(pair_node.getAttribute('id_to')) # Initialise structures if necessary. if not id_from in self._translation_vector: self._translation_vector[id_from] = {} if not id_from in self._translation_distance: self._translation_distance[id_from] = {} if not id_from in self._rotation_matrix: self._rotation_matrix[id_from] = {} if not id_from in self._rotation_axis: self._rotation_axis[id_from] = {} if not id_from in self._rotation_angle: self._rotation_angle[id_from] = {} # A temporary container to place the Python objects into. cont = ModelContainer() # Recreate the Python objects. xml_to_object(pair_node, cont, file_version=file_version) # Repackage the data. for name in ['translation_vector', 'translation_distance', 'rotation_matrix', 'rotation_axis', 'rotation_angle']: # The objects. obj = getattr(self, '_'+name) obj_temp = getattr(cont, name) # Store. obj[id_from][id_to] = obj_temp
def from_xml(self, interatom_nodes, file_version=None): """Recreate an interatomic list data structure from the XML spin nodes. @param interatom_nodes: The spin XML nodes. @type interatom_nodes: xml.dom.minicompat.NodeList instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Test if empty. if not self.is_empty(): raise RelaxFromXMLNotEmptyError(self.__class__.__name__) # Loop over the containers. for interatom_node in interatom_nodes: # Get the interatomic spin details and add a container to the InteratomList structure. spin_id1 = str(interatom_node.getAttribute('spin_id1')) spin_id2 = str(interatom_node.getAttribute('spin_id2')) self.add_item(spin_id1=spin_id1, spin_id2=spin_id2) # Recreate the current container. xml_to_object(interatom_node, self[-1], file_version=file_version)
def from_xml(self, super_node, file_version=1): """Recreate the data structure from the XML node. @param super_node: The XML nodes. @type super_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Recreate all the data structures. xml_to_object(super_node, self, file_version=file_version, blacklist=self.blacklist) # Get the individual elements. nodes = super_node.getElementsByTagName(self.element_name) # Loop over the child nodes. for node in nodes: # Add the data container. self.add_item(node.getAttribute('name')) # Recreate all the other data structures. xml_to_object(node, self[-1], file_version=file_version)
def from_xml(self, exp_info_node, file_version=1): """Recreate the element data structure from the XML element node. @param exp_info_node: The element XML node. @type exp_info_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Recreate the list structures. list_node_names = ['citation_list', 'script_list', 'software_list'] list_subnode_names = ['citation', 'script', 'software'] list_str_names = ['citations', 'scripts', 'software'] for i in range(len(list_node_names)): # Get the list node. list_node = exp_info_node.getElementsByTagName(list_node_names[i]) # Necreate the structure, if the node exists. if list_node: # Initialise the data structure. setattr(self, list_str_names[i], RelaxListType()) list_obj = getattr(self, list_str_names[i]) # Get all the subnodes. list_nodes = list_node[0].getElementsByTagName(list_subnode_names[i]) # Loop over the nodes. for node in list_nodes: # Add a blank container. list_obj.append(Element(name=node.tagName, desc=node.getAttribute('desc'))) # Recreate the element. list_obj[-1].from_xml(node, file_version=file_version) # Recreate all the other data structures. xml_to_object(exp_info_node, self, file_version=file_version, blacklist=list_node_names)
def from_xml(self, gui_node, file_version=1): """Recreate the gui data structure from the XML gui node. @param gui_node: The gui XML node. @type gui_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Init. self.analyses = Analyses() self.free_file_format = Free_file_format() # Get the analyses node and recreate the analyses structure. analyses_nodes = gui_node.getElementsByTagName('analyses') self.analyses.from_xml(analyses_nodes[0], file_version=file_version) # Get the file settings node and recreate the structure. format_nodes = gui_node.getElementsByTagName('free_file_format') if format_nodes: self.free_file_format.from_xml(format_nodes[0], file_version=file_version) # Recreate all the other data structures. xml_to_object(gui_node, self, file_version=file_version, blacklist=['analyses', 'free_file_format'])
def from_xml(self, pipe_node, file_version=None, dir=None): """Read a pipe container XML element and place the contents into this pipe. @param pipe_node: The data pipe XML node. @type pipe_node: xml.dom.minidom.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int @keyword dir: The name of the directory containing the results file (needed for loading external files). @type dir: str """ # Test if empty. if not self.is_empty(): raise RelaxFromXMLNotEmptyError(self.__class__.__name__) # Get the global data node, and fill the contents of the pipe. global_node = pipe_node.getElementsByTagName('global')[0] xml_to_object(global_node, self, file_version=file_version) # Backwards compatibility transformations. self._back_compat_hook(file_version) # Get the hybrid node (and its sub-node), and recreate the hybrid object. hybrid_node = pipe_node.getElementsByTagName('hybrid')[0] pipes_node = hybrid_node.getElementsByTagName('pipes')[0] setattr(self, 'hybrid_pipes', node_value_to_python(pipes_node.childNodes[0])) # Get the experimental information data nodes and, if they exist, fill the contents. exp_info_nodes = pipe_node.getElementsByTagName('exp_info') if exp_info_nodes: # Create the data container. self.exp_info = ExpInfo() # Fill its contents. self.exp_info.from_xml(exp_info_nodes[0], file_version=file_version) # Get the diffusion tensor data nodes and, if they exist, fill the contents. diff_tensor_nodes = pipe_node.getElementsByTagName('diff_tensor') if diff_tensor_nodes: # Create the diffusion tensor object. self.diff_tensor = DiffTensorData() # Fill its contents. self.diff_tensor.from_xml(diff_tensor_nodes[0], file_version=file_version) # Get the alignment tensor data nodes and, if they exist, fill the contents. align_tensor_nodes = pipe_node.getElementsByTagName('align_tensors') if align_tensor_nodes: # Create the alignment tensor object. self.align_tensors = AlignTensorList() # Fill its contents. self.align_tensors.from_xml(align_tensor_nodes[0], file_version=file_version) # Recreate the interatomic data structure (this needs to be before the 'mol' structure as the backward compatibility hooks can create interatomic data containers!). interatom_nodes = pipe_node.getElementsByTagName('interatomic') self.interatomic.from_xml(interatom_nodes, file_version=file_version) # Recreate the molecule, residue, and spin data structure. mol_nodes = pipe_node.getElementsByTagName('mol') self.mol.from_xml(mol_nodes, file_version=file_version) # Get the structural object nodes and, if they exist, fill the contents. str_nodes = pipe_node.getElementsByTagName('structure') if str_nodes: # Create the structural object. fail = False self.structure = Internal() # Fill its contents. if not fail: self.structure.from_xml(str_nodes[0], dir=dir, file_version=file_version)
def from_xml(self, file, dir=None, pipe_to=None, verbosity=1): """Parse a XML document representation of a data pipe, and load it into the relax data store. @param file: The open file object. @type file: file @keyword dir: The name of the directory containing the results file (needed for loading external files). @type dir: str @keyword pipe_to: The data pipe to load the XML data pipe into (the file must only contain one data pipe). @type pipe_to: str @keyword verbosity: A flag specifying the amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int @raises RelaxError: If pipe_to is given and the file contains multiple pipe elements; or if the data pipes in the XML file already exist in the relax data store; or if the data pipe type is invalid; or if the target data pipe is not empty. @raises RelaxNoPipeError: If pipe_to is given but the data pipe does not exist. @raises RelaxError: If the data pipes in the XML file already exist in the relax data store, or if the data pipe type is invalid. @raises RelaxPipeError: If the data pipes of the XML file are already present in the relax data store. """ # Create the XML document from the file. doc = xml.dom.minidom.parse(file) # Get the relax node. relax_node = doc.childNodes[0] # Get the relax version of the XML file. file_version = relax_node.getAttribute('file_version') if file_version == '': file_version = 1 else: file_version = int(file_version) # Get the pipe nodes. pipe_nodes = relax_node.getElementsByTagName('pipe') # Structure for the names of the new pipes. pipes = [] # Target loading to a specific pipe (for pipe results reading). if pipe_to: # Check if there are multiple pipes in the XML file. if len(pipe_nodes) > 1: raise RelaxError( "The pipe_to target pipe argument '%s' cannot be given as the file contains multiple pipe elements." % pipe_to) # The pipe type. pipe_type = pipe_nodes[0].getAttribute('type') # Check that the pipe already exists. if not pipe_to in self: raise RelaxNoPipeError(pipe_to) # Check if the pipe type matches. if pipe_type != self[pipe_to].pipe_type: raise RelaxError( "The XML file pipe type '%s' does not match the pipe type '%s'" % (pipe_type, self[pipe_to].pipe_type)) # Check if the pipe is empty. if not self[pipe_to].is_empty(): raise RelaxError("The data pipe '%s' is not empty." % pipe_to) # Load the data. self[pipe_to].from_xml(pipe_nodes[0], dir=dir, file_version=file_version) # Store the pipe name. pipes.append(pipe_to) # Load the state. else: # Get the GUI nodes. gui_nodes = relax_node.getElementsByTagName('relax_gui') if gui_nodes: self.relax_gui.from_xml(gui_nodes[0], file_version=file_version) # Get the sequence alignment nodes. seq_align_nodes = relax_node.getElementsByTagName( 'sequence_alignments') if seq_align_nodes: # Initialise the object. self.sequence_alignments = Sequence_alignments() # Populate it. self.sequence_alignments.from_xml(seq_align_nodes[0], file_version=file_version) # Recreate all the data store data structures. xml_to_object( relax_node, self, file_version=file_version, blacklist=['pipe', 'relax_gui', 'sequence_alignments']) # Checks. for pipe_node in pipe_nodes: # The pipe name and type. pipe_name = str(pipe_node.getAttribute('name')) pipe_type = pipe_node.getAttribute('type') # Existence check. if pipe_name in self: raise RelaxPipeError(pipe_name) # Valid type check. if not pipe_type in pipe_control.pipes.VALID_TYPES: raise RelaxError( "The data pipe type '%s' is invalid and must be one of the strings in the list %s." % (pipe_type, pipe_control.pipes.VALID_TYPES)) # Load the data pipes. for pipe_node in pipe_nodes: # The pipe name and type. pipe_name = str(pipe_node.getAttribute('name')) pipe_type = pipe_node.getAttribute('type') # Add the data pipe. switch = False if self.current_pipe == None: switch = True self.add(pipe_name, pipe_type, switch=switch) # Fill the pipe. self[pipe_name].from_xml(pipe_node, file_version=file_version, dir=dir) # Store the pipe name. pipes.append(pipe_name) # Set the current pipe. if self.current_pipe in self: builtins.cdp = self[self.current_pipe] # Finally update the molecule, residue, and spin metadata for each data pipe. for pipe in pipes: pipe_control.mol_res_spin.metadata_update(pipe=pipe) # Backwards compatibility transformations. self._back_compat_hook(file_version, pipes=pipes)
def from_xml(self, file, dir=None, pipe_to=None, verbosity=1): """Parse a XML document representation of a data pipe, and load it into the relax data store. @param file: The open file object. @type file: file @keyword dir: The name of the directory containing the results file (needed for loading external files). @type dir: str @keyword pipe_to: The data pipe to load the XML data pipe into (the file must only contain one data pipe). @type pipe_to: str @keyword verbosity: A flag specifying the amount of information to print. The higher the value, the greater the verbosity. @type verbosity: int @raises RelaxError: If pipe_to is given and the file contains multiple pipe elements; or if the data pipes in the XML file already exist in the relax data store; or if the data pipe type is invalid; or if the target data pipe is not empty. @raises RelaxNoPipeError: If pipe_to is given but the data pipe does not exist. @raises RelaxError: If the data pipes in the XML file already exist in the relax data store, or if the data pipe type is invalid. @raises RelaxPipeError: If the data pipes of the XML file are already present in the relax data store. """ # Create the XML document from the file. doc = xml.dom.minidom.parse(file) # Get the relax node. relax_node = doc.childNodes[0] # Get the relax version of the XML file. file_version = relax_node.getAttribute('file_version') if file_version == '': file_version = 1 else: file_version = int(file_version) # Get the pipe nodes. pipe_nodes = relax_node.getElementsByTagName('pipe') # Structure for the names of the new pipes. pipes = [] # Target loading to a specific pipe (for pipe results reading). if pipe_to: # Check if there are multiple pipes in the XML file. if len(pipe_nodes) > 1: raise RelaxError("The pipe_to target pipe argument '%s' cannot be given as the file contains multiple pipe elements." % pipe_to) # The pipe type. pipe_type = pipe_nodes[0].getAttribute('type') # Check that the pipe already exists. if not pipe_to in self: raise RelaxNoPipeError(pipe_to) # Check if the pipe type matches. if pipe_type != self[pipe_to].pipe_type: raise RelaxError("The XML file pipe type '%s' does not match the pipe type '%s'" % (pipe_type, self[pipe_to].pipe_type)) # Check if the pipe is empty. if not self[pipe_to].is_empty(): raise RelaxError("The data pipe '%s' is not empty." % pipe_to) # Load the data. self[pipe_to].from_xml(pipe_nodes[0], dir=dir, file_version=file_version) # Store the pipe name. pipes.append(pipe_to) # Load the state. else: # Get the GUI nodes. gui_nodes = relax_node.getElementsByTagName('relax_gui') if gui_nodes: self.relax_gui.from_xml(gui_nodes[0], file_version=file_version) # Get the sequence alignment nodes. seq_align_nodes = relax_node.getElementsByTagName('sequence_alignments') if seq_align_nodes: # Initialise the object. self.sequence_alignments = Sequence_alignments() # Populate it. self.sequence_alignments.from_xml(seq_align_nodes[0], file_version=file_version) # Recreate all the data store data structures. xml_to_object(relax_node, self, file_version=file_version, blacklist=['pipe', 'relax_gui', 'sequence_alignments']) # Checks. for pipe_node in pipe_nodes: # The pipe name and type. pipe_name = str(pipe_node.getAttribute('name')) pipe_type = pipe_node.getAttribute('type') # Existence check. if pipe_name in self: raise RelaxPipeError(pipe_name) # Valid type check. if not pipe_type in pipe_control.pipes.VALID_TYPES: raise RelaxError("The data pipe type '%s' is invalid and must be one of the strings in the list %s." % (pipe_type, pipe_control.pipes.VALID_TYPES)) # Load the data pipes. for pipe_node in pipe_nodes: # The pipe name and type. pipe_name = str(pipe_node.getAttribute('name')) pipe_type = pipe_node.getAttribute('type') # Add the data pipe. switch = False if self.current_pipe == None: switch = True self.add(pipe_name, pipe_type, switch=switch) # Fill the pipe. self[pipe_name].from_xml(pipe_node, file_version=file_version, dir=dir) # Store the pipe name. pipes.append(pipe_name) # Set the current pipe. if self.current_pipe in self: builtins.cdp = self[self.current_pipe] # Finally update the molecule, residue, and spin metadata for each data pipe. for pipe in pipes: pipe_control.mol_res_spin.metadata_update(pipe=pipe) # Backwards compatibility transformations. self._back_compat_hook(file_version, pipes=pipes)
def from_xml(self, align_tensor_super_node, file_version=1): """Recreate the alignment tensor data structure from the XML alignment tensor node. @param align_tensor_super_node: The alignment tensor XML nodes. @type align_tensor_super_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Recreate all the alignment tensor data structures. xml_to_object(align_tensor_super_node, self, file_version=file_version, blacklist=['align_tensor']) # Get the individual tensors. align_tensor_nodes = align_tensor_super_node.getElementsByTagName( 'align_tensor') # Loop over the child nodes. for align_tensor_node in align_tensor_nodes: # Add the alignment tensor data container. self.add_item(align_tensor_node.getAttribute('name')) # A temporary object to pack the structures from the XML data into. temp_obj = Element() # Recreate all the other data structures (into the temporary object). xml_to_object(align_tensor_node, temp_obj, file_version=file_version) # Loop over all modifiable objects in the temporary object and make soft copies of them. for name in self[-1]._mod_attr: # Skip if missing from the object. if not hasattr(temp_obj, name): continue # The category. if search('_err$', name): category = 'err' param = name.replace('_err', '') elif search('_sim$', name): category = 'sim' param = name.replace('_sim', '') else: category = 'val' param = name # Get the object. value = getattr(temp_obj, name) # Normal parameters. if category == 'val': self[-1].set(param=param, value=value, category=category, update=False) # Errors. elif category == 'err': self[-1].set(param=param, value=value, category=category, update=False) # Simulation objects objects. else: # Set the simulation number if needed. if not hasattr(self[-1], '_sim_num') or self[-1]._sim_num == None: self[-1].set_sim_num(len(value)) # Recreate the list elements. for i in range(len(value)): self[-1].set(param=param, value=value[i], category=category, sim_index=i, update=False) # Update the data structures. for target, update_if_set, depends in dependency_generator(): self[-1]._update_object(param, target, update_if_set, depends, category) # Delete the temporary object. del temp_obj
def from_xml(self, align_tensor_super_node, file_version=1): """Recreate the alignment tensor data structure from the XML alignment tensor node. @param align_tensor_super_node: The alignment tensor XML nodes. @type align_tensor_super_node: xml.dom.minicompat.Element instance @keyword file_version: The relax XML version of the XML file. @type file_version: int """ # Recreate all the alignment tensor data structures. xml_to_object(align_tensor_super_node, self, file_version=file_version, blacklist=['align_tensor']) # Get the individual tensors. align_tensor_nodes = align_tensor_super_node.getElementsByTagName('align_tensor') # Loop over the child nodes. for align_tensor_node in align_tensor_nodes: # Add the alignment tensor data container. self.add_item(align_tensor_node.getAttribute('name')) # A temporary object to pack the structures from the XML data into. temp_obj = Element() # Recreate all the other data structures (into the temporary object). xml_to_object(align_tensor_node, temp_obj, file_version=file_version) # Loop over all modifiable objects in the temporary object and make soft copies of them. for name in self[-1]._mod_attr: # Skip if missing from the object. if not hasattr(temp_obj, name): continue # The category. if search('_err$', name): category = 'err' param = name.replace('_err', '') elif search('_sim$', name): category = 'sim' param = name.replace('_sim', '') else: category = 'val' param = name # Get the object. value = getattr(temp_obj, name) # Normal parameters. if category == 'val': self[-1].set(param=param, value=value, category=category, update=False) # Errors. elif category == 'err': self[-1].set(param=param, value=value, category=category, update=False) # Simulation objects objects. else: # Set the simulation number if needed. if not hasattr(self[-1], '_sim_num') or self[-1]._sim_num == None: self[-1].set_sim_num(len(value)) # Recreate the list elements. for i in range(len(value)): self[-1].set(param=param, value=value[i], category=category, sim_index=i, update=False) # Update the data structures. for target, update_if_set, depends in dependency_generator(): self[-1]._update_object(param, target, update_if_set, depends, category) # Delete the temporary object. del temp_obj