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
