def _g_refNode(self, childNode, childName, validate=True): """ Insert references to a `childNode` via a `childName`. Checks that the `childName` is valid and does not exist, then creates references to the given `childNode` by that `childName`. The validation of the name can be omitted by setting `validate` to a false value (this may be useful for adding already existing nodes to the tree). """ # Check for name validity. if validate: checkNameValidity(childName) childNode._g_checkName(childName) # Check if there is already a child with the same name. # This can be triggered because of the user # (via node construction or renaming/movement). # Links are not checked here because they are copied and referenced # using ``File.getNode`` so they already exist in `self`. if (not isinstance(childNode, Link)) and childName in self: raise NodeError( "group ``%s`` already has a child node named ``%s``" % (self._v_pathname, childName)) # Show a warning if there is an object attribute with that name. if childName in self.__dict__: warnings.warn( "group ``%s`` already has an attribute named ``%s``; " "you will not be able to use natural naming " "to access the child node" % (self._v_pathname, childName), NaturalNameWarning) # Check group width limits. if len(self._v_children) + len(self._v_hidden) >= self._v_maxGroupWidth: self._g_widthWarning() # Update members information. # Insert references to the new child. # (Assigned values are entirely irrelevant.) if isVisibleName(childName): # Visible node. self.__members__.insert(0, childName) # enable completion self._v_children[childName] = None # insert node if isinstance(childNode, Unknown): self._v_unknown[childName] = None elif isinstance(childNode, Link): self._v_links[childName] = None elif isinstance(childNode, Leaf): self._v_leaves[childName] = None elif isinstance(childNode, Group): self._v_groups[childName] = None else: # Hidden node. self._v_hidden[childName] = None # insert node
def __setattr__(self, name, value): """ Set a PyTables attribute. Sets a (maybe new) PyTables attribute with the specified `name` and `value`. If the attribute already exists, it is simply replaced. A ``ValueError`` is raised when the name starts with a reserved prefix or contains a ``/``. A `NaturalNameWarning` is issued if the name is not a valid Python identifier. A `PerformanceWarning` is issued when the recommended maximum number of attributes in a node is going to be exceeded. """ nodeFile = self._v__nodeFile attrnames = self._v_attrnames # Check for name validity checkNameValidity(name) nodeFile._checkWritable() # Check if there are too many attributes. maxNodeAttrs = nodeFile.params["MAX_NODE_ATTRS"] if len(attrnames) >= maxNodeAttrs: warnings.warn( """\ node ``%s`` is exceeding the recommended maximum number of attributes (%d);\ be ready to see PyTables asking for *lots* of memory and possibly slow I/O""" % (self._v__nodePath, maxNodeAttrs), PerformanceWarning, ) undoEnabled = nodeFile.isUndoEnabled() # Log old attribute removal (if any). if undoEnabled and (name in attrnames): self._g_delAndLog(name) # Set the attribute. self._g__setattr(name, value) # Log new attribute addition. if undoEnabled: self._g_logAdd(name)
def __setattr__(self, name, value): """ Set a PyTables attribute. Sets a (maybe new) PyTables attribute with the specified `name` and `value`. If the attribute already exists, it is simply replaced. A ``ValueError`` is raised when the name starts with a reserved prefix or contains a ``/``. A `NaturalNameWarning` is issued if the name is not a valid Python identifier. A `PerformanceWarning` is issued when the recommended maximum number of attributes in a node is going to be exceeded. """ nodeFile = self._v__nodeFile attrnames = self._v_attrnames # Check for name validity checkNameValidity(name) nodeFile._checkWritable() # Check if there are too many attributes. maxNodeAttrs = nodeFile.params['MAX_NODE_ATTRS'] if len(attrnames) >= maxNodeAttrs: warnings.warn("""\ node ``%s`` is exceeding the recommended maximum number of attributes (%d);\ be ready to see PyTables asking for *lots* of memory and possibly slow I/O""" % (self._v__nodePath, maxNodeAttrs), PerformanceWarning) undoEnabled = nodeFile.isUndoEnabled() # Log old attribute removal (if any). if undoEnabled and (name in attrnames): self._g_delAndLog(name) # Set the attribute. self._g__setattr(name, value) # Log new attribute addition. if undoEnabled: self._g_logAdd(name)
def __init__(self, classdict, nestedlvl=-1, validate=True): # Do a shallow copy of classdict just in case this is going to # be shared by other instances newdict = self.__dict__ newdict["_v_name"] = "/" # The name for root descriptor newdict["_v_names"] = [] newdict["_v_dtypes"] = {} newdict["_v_types"] = {} newdict["_v_dflts"] = {} newdict["_v_colObjects"] = {} newdict["_v_is_nested"] = False nestedFormats = [] nestedDType = [] if not hasattr(newdict, "_v_nestedlvl"): newdict["_v_nestedlvl"] = nestedlvl + 1 cols_with_pos = [] # colum (position, name) pairs cols_no_pos = [] # just column names # Check for special variables and convert column descriptions for (name, descr) in classdict.items(): if (name.startswith('__') or name.startswith('_v_')): if name in newdict: #print "Warning!" # special methods &c: copy to newdict, warn about conflicts warnings.warn("Can't set attr %r in description class %r" \ % (name, self)) else: #print "Special variable!-->", name, classdict[name] newdict[name] = descr continue # This variable is not needed anymore columns = None if (type(descr) == type(IsDescription) and issubclass(descr, IsDescription)): #print "Nested object (type I)-->", name columns = descr().columns elif (type(descr.__class__) == type(IsDescription) and issubclass(descr.__class__, IsDescription)): #print "Nested object (type II)-->", name columns = descr.columns elif isinstance(descr, dict): #print "Nested object (type III)-->", name columns = descr else: #print "Nested object (type IV)-->", name descr = copy.copy(descr) # The copies above and below ensure that the structures # provided by the user will remain unchanged even if we # tamper with the values of ``_v_pos`` here. if columns is not None: descr = Description(copy.copy(columns), self._v_nestedlvl) classdict[name] = descr pos = getattr(descr, '_v_pos', None) if pos is None: cols_no_pos.append(name) else: cols_with_pos.append((pos, name)) # Sort field names: # # 1. Fields with explicit positions, according to their # positions (and their names if coincident). # 2. Fields with no position, in alfabetical order. cols_with_pos.sort() cols_no_pos.sort() keys = [name for (pos, name) in cols_with_pos] + cols_no_pos pos = 0 # Get properties for compound types for k in keys: if validate: # Check for key name validity checkNameValidity(k) # Class variables object = classdict[k] newdict[k] = object # To allow natural naming if not (isinstance(object, Col) or isinstance(object, Description)): raise TypeError, \ """Passing an incorrect value to a table column. Expected a Col (or subclass) instance and got: "%s". Please make use of the Col(), or descendant, constructor to properly initialize columns. """ % object object._v_pos = pos # Set the position of this object object._v_parent = self # The parent description pos += 1 newdict['_v_colObjects'][k] = object newdict['_v_names'].append(k) object.__dict__['_v_name'] = k if isinstance(object, Col): dtype = object.dtype newdict['_v_dtypes'][k] = dtype newdict['_v_types'][k] = object.type newdict['_v_dflts'][k] = object.dflt nestedFormats.append(object.recarrtype) baserecarrtype = dtype.base.str[1:] nestedDType.append((k, baserecarrtype, dtype.shape)) else: # A description nestedFormats.append(object._v_nestedFormats) nestedDType.append((k, object._v_dtype)) # Assign the format list to _v_nestedFormats newdict['_v_nestedFormats'] = nestedFormats newdict['_v_dtype'] = numpy.dtype(nestedDType) # _v_itemsize is derived from the _v_dtype that already computes this newdict['_v_itemsize'] = newdict['_v_dtype'].itemsize if self._v_nestedlvl == 0: # Get recursively nested _v_nestedNames and _v_nestedDescr attrs self._g_setNestedNamesDescr() # Get pathnames for nested groups self._g_setPathNames() # Check the _v_byteorder has been used an issue an Error if hasattr(self, "_v_byteorder"): raise ValueError( "Using a ``_v_byteorder`` in the description is obsolete. " "Use the byteorder parameter in the constructor instead.")