class LogMetadata(tuple): 'LogMetadata()' __slots__ = () _fields = ('aim', 'authors', 'strain', 'comments', 'brightfield', 'dic', 'gfp', 'gfpfast', 'cy5', 'project', 'description', 'tags', 'exp_start_date', 'table_dict', 'kvp_list') def __new__(_cls): 'Create new instance of Point(x, y)' return _tuple.__new__(_cls) def __repr__(self): 'Return a nicely formatted representation string' return 'LogMetadata(aim=%r, strain=%r, comments=%r, brightfield=%r,' \ 'dic=%r, gfp=%r, project=%r, tags=%r, exp_start_date=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values' return OrderedDict(list(zip(self._fields, self))) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) __dict__ = _property(_asdict) def __getstate__(self): 'Exclude the OrderedDict from pickling' pass aim = _property(_itemgetter(0), doc='Alias for field aim') strain = _property(_itemgetter(1), doc='Alias for field strain')
class AcqAnnotation(tuple): 'AcqAnnotation()' __slots__ = () _fields = ('channels', 'zsections', 'times', 'positions', 'npumps', 'pump_init', 'switch_params', 'table_dict', 'kvp_list') def __new__(_cls): 'Create new instance of Point(x, y)' return _tuple.__new__(_cls) def __repr__(self): 'Return a nicely formatted representation string' return 'Point(channels=%r, zsections=%r, times=%r, positions=%r,' \ 'npumps=%r, pump_init=%r, switch_params=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values' return OrderedDict(list(zip(self._fields, self))) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) __dict__ = _property(_asdict) def __getstate__(self): 'Exclude the OrderedDict from pickling' pass channels = _property(_itemgetter(0), doc='Alias for field channels') zsections = _property(_itemgetter(1), doc='Alias for field zsections')
class MetadataSection(tuple): 'MetadataSection()' __slots__ = () _fields = ('id', 'label', 'regex', 'data_type', 'rx') def __new__(_cls): 'Create new instance of Point(x, y)' return _tuple.__new__(_cls) def __repr__(self): 'Return a nicely formatted representation string' return 'MetadataSection(id=%r, label=%r, regex=%r, data_type=%r,' \ 'rx=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values' return OrderedDict(list(zip(self._fields, self))) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) __dict__ = _property(_asdict) def __getstate__(self): 'Exclude the OrderedDict from pickling' pass id = _property(_itemgetter(0), doc='Alias for field id') label = _property(_itemgetter(1), doc='Alias for field label')
class Point(tuple): """Point(quantity, price)""" __slots__ = () _fields = ('quantity', 'price') def __new__(_cls, quantity, price): """Create new instance of Point(quantity, price)""" # if (quantity < 0 or quantity is None): # raise ValueError('The quantity provided ({}) is an invalid value.'.format(quantity)) # if (price < 0 or price is None): # raise ValueError('The price provided ({}) is an invalid value.'.format(price)) # Catch exception to float_quantity = float(quantity) float_price = float(price) return _tuple.__new__(_cls, (float_quantity, float_price)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): """Make a new Point object from a sequence or iterable""" result = new(cls, iterable) if len(result) != 2: raise TypeError('Expected 2 arguments, got %d' % len(result)) return result def __repr__(self): """Return a nicely formatted representation string""" return 'Point(quantity=%r, price=%r)' % self def _asdict(self): """Return a new OrderedDict which maps field names to their values""" return OrderedDict(zip(self._fields, self)) def _replace(_self, **kwds): """Return a new Point object replacing specified fields with new values""" result = _self._make(map(kwds.pop, ('quantity', 'price'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % kwds.keys()) return result def __getnewargs__(self): """Return self as a plain tuple. Used by copy and pickle.""" return tuple(self) __dict__ = _property(_asdict) def __getstate__(self): """Exclude the OrderedDict from pickling""" pass def tuppleize(self): return (self.quantity, self.price) quantity = _property(_itemgetter(0), doc='Alias for field number 0') x = _property(_itemgetter(0), doc='Alias for field number 0') price = _property(_itemgetter(1), doc='Alias for field number 1') y = _property(_itemgetter(1), doc='Alias for field number 1')
class VectorValue(tuple): """ # from collections import namedtuple # value_type = namedtuple('VectorValue', ['x', 'y', 'z']) """ 'VectorValue(x, y, z)' __slots__ = () _fields = ('x', 'y', 'z') def __new__(_cls, x, y, z): 'Create new instance of VectorValue(x, y, z)' return _tuple.__new__(_cls, (x, y, z)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new VectorValue object from a sequence or iterable' result = new(cls, iterable) if len(result) != 3: raise TypeError('Expected 3 arguments, got %d' % len(result)) return result def _replace(_self, **kwds): """Return a new VectorValue object replacing specified fields with new values """ result = _self._make(map(kwds.pop, ('x', 'y', 'z'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__\ + '(x=%r, y=%r, z=%r)'\ % (self.x, self.y, self.z) def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) x = _property(_itemgetter(0), doc='Alias for field number 0') y = _property(_itemgetter(1), doc='Alias for field number 1') z = _property(_itemgetter(2), doc='Alias for field number 2')
class TPoint(tuple): """TPoint(x, y)""" __slots__ = () _fields = ('x', 'y') def __new__(_cls, x, y): 'Create new instance of TPoint(x, y)' return _tuple.__new__(_cls, (x, y)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new TPoint object from a sequence or iterable' result = new(cls, iterable) if len(result) != 2: raise TypeError('Expected 2 arguments, got %d' % len(result)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + '(x=%r, y=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values' return OrderedDict(zip(self._fields, self)) __dict__ = property(_asdict) def _replace(_self, **kwds): 'Return a new TPoint object replacing specified fields with new values' result = _self._make(map(kwds.pop, ('x', 'y'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) x = _property(_itemgetter(0), doc='Alias for field number 0') y = _property(_itemgetter(1), doc='Alias for field number 1')
class Character(tuple): 'Character(name, owner, description, level, team, meta)' __slots__ = () _fields = ('name', 'owner', 'description', 'level', 'team', 'meta', 'ustats') def __new__(_cls, name, owner, description, level, team, meta, ustats=None): 'Create new instance of Character(name, owner, description, level, team, meta)' if ustats is None: ustats = {} return _tuple.__new__( _cls, (name, owner, description, level, team, meta, ustats)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new Character object from a sequence or iterable' result = new(cls, iterable) if len(result) != 6: raise TypeError('Expected 6 arguments, got %d' % len(result)) return result def _replace(_self, **kwds): 'Return a new Character object replacing specified fields with new values' result = _self._make( map(kwds.pop, ('name', 'owner', 'description', 'level', 'team', 'meta'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + '(name=%r, owner=%r, description=%r, level=%r, team=%r, meta=%r, ustats=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) name = _property(_itemgetter(0), doc='Alias for field number 0') owner = _property(_itemgetter(1), doc='Alias for field number 1') description = _property(_itemgetter(2), doc='Alias for field number 2') level = _property(_itemgetter(3), doc='Alias for field number 3') team = _property(_itemgetter(4), doc='Alias for field number 4') meta = _property(_itemgetter(5), doc='Alias for field number 5') ustats = _property(_itemgetter(6), doc='Alias for field number 6')
class StatsTuple(tuple): ''' tuple subclass used to track edit_distance and related values. Copy-and-paste-and-modify of NamedTuple _source with addition operator overridden Attributes: ---------- edit_distance : int num_deletions : int num_insertions :int num_substituions : int num_ref_elements :int ''' __slots__ = () _fields = ('edit_distance', 'num_deletions', 'num_insertions', 'num_substituions', 'num_ref_elements') def __new__(_cls, edit_distance, num_deletions, num_insertions, num_substituions, num_ref_elements): '''Create new instance of DiffStats(edit_distance, num_deletions, num_insertions, num_substituions, num_ref_elements, alignment)''' return _tuple.__new__(_cls, (edit_distance, num_deletions, num_insertions, num_substituions, num_ref_elements)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new DiffStats object from a sequence or iterable' result = new(cls, iterable) if len(result) != 5: raise TypeError('Expected 5 arguments, got %d' % len(result)) return result def _replace(_self, **kwds): '''Return a new StatsTuple object replacing specified fields with new values''' result = _self._make( map(kwds.pop, ('edit_distance', 'num_deletions', 'num_insertions', 'num_substituions', 'num_ref_elements'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + ( '(edit_distance=%r, num_deletions=%r, num_insertions=%r, ' 'num_substituions=%r, num_ref_elements=%r)' % self) def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) def __add__(self, other): ''' add all the attributes together and return a new StatsTuple object ''' return StatsTuple(*(i + j for i, j in zip(self, other))) edit_distance = _property(_itemgetter(0), doc='Alias for field number 0') num_deletions = _property(_itemgetter(1), doc='Alias for field number 1') num_insertions = _property(_itemgetter(2), doc='Alias for field number 2') num_substituions = _property(_itemgetter(3), doc='Alias for field number 3') num_ref_elements = _property(_itemgetter(4), doc='Alias for field number 4')
class Position(tuple): 'Position(top, right, bottom, left)' __slots__ = () _fields = ('top', 'right', 'bottom', 'left') def __new__(_cls, top, right, bottom, left): 'Create new instance of Position(top, right, bottom, left)' return _tuple.__new__(_cls, (top, right, bottom, left)) @classmethod def make(cls, in_iterable, new=tuple.__new__, len=len): """Make a new Position object from a sequence or iterable Parameters --------- in_iterable List of parameters to set position. Rules are same as in CSS (padding, margin, border etc.): - 1 value sets all 4 fields. - 2 values: (first sets top and bottom, 2nd sets left and right) - 3 values: (first sets top, second left/right and third bottom - 4 values: (sets in order: top, right, bottom, left) """ if len(in_iterable) == 1: iterable = itertools.repeat(in_iterable[0], 4) elif len(in_iterable) == 2: iterable = [ in_iterable[0], in_iterable[1], in_iterable[0], in_iterable[1] ] elif len(in_iterable) == 3: iterable = in_iterable + [in_iterable[1]] else: iterable = in_iterable result = new(cls, iterable) if len(result) != 4: raise TypeError('Expected 4 arguments, got %d' % len(result)) return result def _replace(_self, **kwds): 'Return a new Position object replacing specified fields with new values' result = _self._make( map(kwds.pop, ('top', 'right', 'bottom', 'left'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + '(top=%r, right=%r, bottom=%r, left=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return collections.OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) top = _property(_itemgetter(0), doc='top margin/padding') right = _property(_itemgetter(1), doc='right margin/padding') bottom = _property(_itemgetter(2), doc='bottom margin/padding') left = _property(_itemgetter(3), doc='left margin/padding')
@classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new TIPO object from a sequence or iterable' result = new(cls, iterable) if len(result) != 1: raise TypeError('Expected 1 arguments, got %d' % len(result)) return result def _replace(_self, **kwds): 'Return a new TIPO object replacing specified fields with new values' result = _self._make(map(kwds.pop, ('VALOR',), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + '(VALOR=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) VALOR = _property(_itemgetter(0), doc='Alias for field number 0')
class TaskRecord(tuple): 'TaskRecord(name, sent_at, started_at, succeeded_at, failed_at)' __slots__ = () _fields = ('name', 'sent_at', 'started_at', 'succeeded_at', 'failed_at') def __new__(_cls, name, sent_at, started_at, succeeded_at, failed_at): 'Create new instance of TaskRecord(name, sent_at, started_at, succeeded_at, failed_at)' return _tuple.__new__( _cls, (name, sent_at, started_at, succeeded_at, failed_at)) @classmethod def _make(cls, iterable, new=tuple.__new__, len=len): 'Make a new TaskRecord object from a sequence or iterable' result = new(cls, iterable) if len(result) != 5: raise TypeError('Expected 5 arguments, got %d' % len(result)) return result def _replace(_self, **kwds): 'Return a new TaskRecord object replacing specified fields with new values' result = _self._make( map(kwds.pop, ('name', 'sent_at', 'started_at', 'succeeded_at', 'failed_at'), _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): 'Return a nicely formatted representation string' return self.__class__.__name__ + '(name=%r, sent_at=%r, started_at=%r, succeeded_at=%r, failed_at=%r)' % self def _asdict(self): 'Return a new OrderedDict which maps field names to their values.' return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): 'Return self as a plain tuple. Used by copy and pickle.' return tuple(self) name = _property(_itemgetter(0), doc='Alias for field number 0') sent_at = _property(_itemgetter(1), doc='Alias for field number 1') started_at = _property(_itemgetter(2), doc='Alias for field number 2') succeeded_at = _property(_itemgetter(3), doc='Alias for field number 3') failed_at = _property(_itemgetter(4), doc='Alias for field number 4') @property def started(self): return self.sent_at is not None and self.started_at is not None @property def wait_duration(self): return self.started_at - self.sent_at @property def finished(self): return self.succeeded_at is not None or self.failed_at is not None @property def successful(self): return self.succeeded_at is not None @property def processing_duration(self): return self.succeeded_at - self.started_at
def namedtuple(typename, field_names, *, verbose=False, rename=False, module=None): """Returns a new subclass of tuple with named fields. >>> Point = namedtuple('Point', ['x', 'y']) >>> Point.__doc__ # docstring for the new class 'Point(x, y)' >>> p = Point(11, y=22) # instantiate with positional args or keywords >>> p[0] + p[1] # indexable like a plain tuple 33 >>> x, y = p # unpack like a regular tuple >>> x, y (11, 22) >>> p.x + p.y # fields also accessible by name 33 >>> d = p._asdict() # convert to a dictionary >>> d['x'] 11 >>> Point(**d) # convert from a dictionary Point(x=11, y=22) >>> p._replace(x=100) # _replace() is like str.replace() but targets named fields Point(x=100, y=22) """ # Validate the field names. At the user's option, either generate an error # message or automatically replace the field name with a valid name. if isinstance(field_names, str): field_names = field_names.replace(',', ' ').split() field_names = list(map(str, field_names)) typename = str(typename) if rename: seen = set() for index, name in enumerate(field_names): if (not name.isidentifier() or _iskeyword(name) or name.startswith('_') or name in seen): field_names[index] = '_%d' % index seen.add(name) for name in [typename] + field_names: if type(name) is not str: raise TypeError('Type names and field names must be strings') if not name.isidentifier(): raise ValueError('Type names and field names must be valid ' 'identifiers: %r' % name) if _iskeyword(name): raise ValueError('Type names and field names cannot be a ' 'keyword: %r' % name) seen = set() for name in field_names: if name.startswith('_') and not rename: raise ValueError('Field names cannot start with an underscore: ' '%r' % name) if name in seen: raise ValueError('Encountered duplicate field name: %r' % name) seen.add(name) field_names = tuple(field_names) num_fields = len(field_names) _repr_template = '{name}=%r' repr_fmt = ', '.join( _repr_template.format(name=name) for name in field_names) _UNSET = object() class _KlassDef(tuple): __slots__ = () _fields = field_names def __new__(_cls, *args, **kwargs): if len(args) > len(field_names): msg = '__new__() takes %d positional arguments but %d were given' msg = msg % (len(field_names) + 1, len(args) + 1) raise TypeError(msg) values = list(args) + [_UNSET] * (len(field_names) - len(args)) for k, v in kwargs.items(): try: i = field_names.index(k) except ValueError: msg = "__new__() got an unexpected keyword argument '%s'" msg = msg % k raise TypeError(msg) if values[i] is not _UNSET: msg = "__new__() got multiple values for argument '%s'" msg = msg % k raise TypeError(msg) values[i] = v missing = [] for i, v in enumerate(values): if v is _UNSET: missing.append(field_names[i]) if missing: msg = "__new__() missing %d required positional argument%s:" msg = msg % (len(missing), 's' if len(missing) > 1 else '') msg += ', '.join("'%s'" % m for m in missing) if ',' in msg: msg = msg.rsplit(',', 1)[0] + " and '%s'" % missing[-1] raise TypeError(msg) return _tuple.__new__(_cls, values) @classmethod def _make(cls, iterable, new=tuple.__new__): result = new(cls, iterable) if len(result) != num_fields: raise TypeError('Expected %d arguments, got %d' % (num_fields, len(result))) return result def _replace(_self, **kwds): result = _self._make(map(kwds.pop, field_names, _self)) if kwds: raise ValueError('Got unexpected field names: %r' % list(kwds)) return result def __repr__(self): return self.__class__.__name__ + f'({repr_fmt})' % self def _asdict(self): return OrderedDict(zip(self._fields, self)) def __getnewargs__(self): return tuple(self) for index, name in enumerate(field_names): field = _property(_itemgetter(index), doc=f'Alias for field number {index:d}') setattr(_KlassDef, name, field) _KlassDef.__name__ = typename return _KlassDef