def references(self): """ A property containing all data arrays referenced by the tag. Referenced data arrays can be obtained by index or their id. References can be removed from the list, removing a referenced DataArray will not remove it from the file. New references can be added using the append method of the list. This is a read only attribute. :type: RefProxyList of DataArray """ if not hasattr(self, "_references"): setattr(self, "_references", ReferenceProxyList(self)) return self._references @property def features(self): """ A property containing all features of the tag. Features can be obtained via their index or their id. Features can be deleted from the list. Adding new features to the tag is done using the create_feature method. This is a read only attribute. :type: ProxyList of Feature. """ if not hasattr(self, "_features"): setattr(self, "_features", FeatureProxyList(self)) return self._features inject((Tag, ), dict(TagMixin.__dict__))
def references(self): """ A property containing all data arrays referenced by the tag. Referenced data arrays can be obtained by index or their id. References can be removed from the list, removing a referenced DataArray will not remove it from the file. New references can be added using the append method of the list. This is a read only attribute. :type: RefProxyList of DataArray """ if not hasattr(self, "_references"): setattr(self, "_references", ReferenceProxyList(self)) return self._references @property def features(self): """ A property containing all features of the tag. Features can be obtained via their index or their id. Features can be deleted from the list. Adding new features to the tag is done using the create_feature method. This is a read only attribute. :type: ProxyList of Feature. """ if not hasattr(self, "_features"): setattr(self, "_features", FeatureProxyList(self)) return self._features inject((Tag,), dict(TagMixin.__dict__))
if hasattr(other, "id"): return self.id == other.id else: return False def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) class ValueMixin(Value): def __eq__(self, other): if hasattr(other, "value"): return self.value == other.value else: return self.value == other def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) inject((Property, ), dict(PropertyMixin.__dict__)) inject((Value, ), dict(ValueMixin.__dict__))
will be added to the result list. By default a filter is used that accepts all sections. :param filtr: A filter function :type filtr: function :param limit: The maximum depth of traversal :type limit: int :returns: A list containing the matching sections. :rtype: list of Section """ return finders._find_sections(self, filtr, limit) @property def sections(self): """ A property containing all root sections of a file. Specific root sections can be obtained by their id or their index. Sections can be deleted from this list. Notice: when a section is deleted all its child section and properties will be removed too. Adding a new Section is done via the crate_section method of File. This is a read-only property. :type: ProxyList of Section entities. """ if not hasattr(self, "_sections"): setattr(self, "_sections", SectionProxyList(self)) return self._sections inject((File,), dict(FileMixin.__dict__))
def groups(self): """ A property containing all groups of a block. Group entities can be obtained via their index or by their id. Groups can be deleted from the list. Adding a Group is done using the Blocks create_group method. This is a read only attribute. :type: ProxyList of Group entities. """ if not hasattr(self, "_groups"): setattr(self, "_groups", GroupProxyList(self)) return self._groups def __eq__(self, other): """ Two blocks are considered equal when they have the same id """ if hasattr(other, "id"): return self.id == other.id else: return False def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) inject((Block, ), dict(BlockMixin.__dict__))
def references(self): """ A property containing all data arrays referenced by the tag. Referenced data arrays can be obtained by index or their id. References can be removed from the list, removing a referenced DataArray will not remove it from the file. New references can be added using the append method of the list. This is a read only attribute. :type: RefProxyList of DataArray """ if not hasattr(self, "_references"): setattr(self, "_references", ReferenceProxyList(self)) return self._references @property def features(self): """ A property containing all features of the tag. Features can be obtained via their index or their id. Features can be deleted from the list. Adding new features to the tag is done using the create_feature method. This is a read only attribute. :type: ProxyList of Feature. """ if not hasattr(self, "_features"): setattr(self, "_features", FeatureProxyList(self)) return self._features inject((MultiTag,), dict(MultiTagMixin.__dict__))
for s in self.sections: yield (s.name, s) def __contains__(self, key): return key in self.props or key in self.sections @property def props(self): """ A property containing all Property entities associated with the section. Properties can be accessed by index of via their id. Properties can be deleted from the list. Adding new properties is done using the create_property method. This is a read-only attribute. :type: ProxyList of Property """ if not hasattr(self, "_properties_proxy"): setattr(self, "_properties_proxy", PropertyProxyList(self)) return self._properties_proxy def _get_property_by_id_or_name(self, ident): """ Helper method that gets a property by id or name """ p = self._get_property_by_id(ident) if p is None and self.has_property_by_name(ident): p = self.get_property_by_name(ident) return p inject((Section,), dict(SectionMixin.__dict__))
:type filtr: function :param limit: The maximum depth of traversal :type limit: int :returns: A list containing the matching sources. :rtype: list of Source """ return finders._find_sources(self, filtr, limit) @property def sources(self): if not hasattr(self, "_sources"): setattr(self, "_sources", SourceProxyList(self)) return self._sources def __eq__(self, other): if hasattr(other, "id"): return self.id == other.id else: return False def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) inject((Source,), dict(SourceMixin.__dict__))
# here we handle Ellipsis in the middle of the tuple # we *can* only handle one, if there are more, then # __complete_slices will raise a InvalidIndex error pos = index.index(Ellipsis) if Ellipsis in index else -1 if pos > -1: index = index[:pos] + fill_none(shape, index) + index[pos+1:] # in python3 map does not work with None therefore if # len(shape) != len(index) we wont get the expected # result. We therefore need to fill up the missing values index = index + fill_none(shape, index, to_replace=0) completed = list(map(self.__complete_slices, shape, index)) combined = list(map(lambda s: (s.start, s.stop), completed)) count = tuple(x[1] - x[0] for x in combined) offset = [x for x in zip(*combined)][0] # drop all indices from count that came from single ints # NB: special case when we only have ints, e.g. (int, ) then # we get back the empty tuple and this is what we want, # because it indicates a scalar result squeezed = map(lambda i, c: c if type(i) != int else None, index, count) shape = list(filter(lambda x: x is not None, squeezed)) return count, offset, shape inject((DataArray,), dict(DataArrayMixin.__dict__)) inject((DataSet,), dict(DataSetMixin.__dict__))
return self.id == other.id else: return False def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) class ValueMixin(Value): def __eq__(self, other): if hasattr(other, "value"): return self.value == other.value else: return self.value == other def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) inject((Property,), dict(PropertyMixin.__dict__)) inject((Value,), dict(ValueMixin.__dict__))
will be added to the result list. By default a filter is used that accepts all sections. :param filtr: A filter function :type filtr: function :param limit: The maximum depth of traversal :type limit: int :returns: A list containing the matching sections. :rtype: list of Section """ return finders._find_sections(self, filtr, limit) @property def sections(self): """ A property containing all root sections of a file. Specific root sections can be obtained by their id or their index. Sections can be deleted from this list. Notice: when a section is deleted all its child section and properties will be removed too. Adding a new Section is done via the crate_section method of File. This is a read-only property. :type: ProxyList of Section entities. """ if not hasattr(self, "_sections"): setattr(self, "_sections", SectionProxyList(self)) return self._sections inject((File, ), dict(FileMixin.__dict__))
# here we handle Ellipsis in the middle of the tuple # we *can* only handle one, if there are more, then # __complete_slices will raise a InvalidIndex error pos = index.index(Ellipsis) if Ellipsis in index else -1 if pos > -1: index = index[:pos] + fill_none(shape, index) + index[pos + 1:] # in python3 map does not work with None therefore if # len(shape) != len(index) we wont get the expected # result. We therefore need to fill up the missing values index = index + fill_none(shape, index, to_replace=0) completed = list(map(self.__complete_slices, shape, index)) combined = list(map(lambda s: (s.start, s.stop), completed)) count = tuple(x[1] - x[0] for x in combined) offset = [x for x in zip(*combined)][0] # drop all indices from count that came from single ints # NB: special case when we only have ints, e.g. (int, ) then # we get back the empty tuple and this is what we want, # because it indicates a scalar result squeezed = map(lambda i, c: c if type(i) != int else None, index, count) shape = list(filter(lambda x: x is not None, squeezed)) return count, offset, shape inject((DataArray, ), dict(DataArrayMixin.__dict__)) inject((DataSet, ), dict(DataSetMixin.__dict__))
def tags(self): """ A property containing all tags referenced by the group. Tags can be obtained by index or their id. Tags can be removed from the list, removing a referenced Tag will not remove it from the file. New Tags can be added using the append method of the list. This is a read only attribute. :type: TagProxyList of Tags """ if not hasattr(self, "_tags"): setattr(self, "_tags", TagProxyList(self)) return self._tags @property def multi_tags(self): """ A property containing all MultiTags referenced by the group. MultiTags can be obtained by index or their id. Tags can be removed from the list, removing a referenced MultiTag will not remove it from the file. New MultiTags can be added using the append method of the list. This is a read only attribute. :type: MultiTagProxyList of MultiTags """ if not hasattr(self, "_multi_tags"): setattr(self, "_multi_tags", MultiTagProxyList(self)) return self._multi_tags inject((Group,), dict(GroupMixin.__dict__))
def groups(self): """ A property containing all groups of a block. Group entities can be obtained via their index or by their id. Groups can be deleted from the list. Adding a Group is done using the Blocks create_group method. This is a read only attribute. :type: ProxyList of Group entities. """ if not hasattr(self, "_groups"): setattr(self, "_groups", GroupProxyList(self)) return self._groups def __eq__(self, other): """ Two blocks are considered equal when they have the same id """ if hasattr(other, "id"): return self.id == other.id else: return False def __hash__(self): """ overwriting method __eq__ blocks inheritance of __hash__ in Python 3 hash has to be either explicitly inherited from parent class, implemented or escaped """ return hash(self.id) inject((Block,), dict(BlockMixin.__dict__))
"_get_source_by_pos", "_remove_source_by_id", "_add_source_by_id") _sources_doc = """ Getter for sources. """ def _get_sources(self): if not hasattr(self, "_sources"): setattr(self, "_sources", RefSourceProxyList(self)) return self._sources class DataArraySourcesMixin(DataArray): sources = property(_get_sources, None, None, _sources_doc) class MultiTagSourcesMixin(MultiTag): sources = property(_get_sources, None, None, _sources_doc) class TagSourcesMixin(Tag): sources = property(_get_sources, None, None, _sources_doc) inject((DataArray,), dict(DataArraySourcesMixin.__dict__)) inject((MultiTag,), dict(MultiTagSourcesMixin.__dict__)) inject((Tag,), dict(TagSourcesMixin.__dict__))
for s in self.sections: yield (s.name, s) def __contains__(self, key): return key in self.props or key in self.sections @property def props(self): """ A property containing all Property entities associated with the section. Properties can be accessed by index of via their id. Properties can be deleted from the list. Adding new properties is done using the create_property method. This is a read-only attribute. :type: ProxyList of Property """ if not hasattr(self, "_properties_proxy"): setattr(self, "_properties_proxy", PropertyProxyList(self)) return self._properties_proxy def _get_property_by_id_or_name(self, ident): """ Helper method that gets a property by id or name """ p = self._get_property_by_id(ident) if p is None and self.has_property_by_name(ident): p = self.get_property_by_name(ident) return p inject((Section, ), dict(SectionMixin.__dict__))