fchm:dSrSSKrSSKJr SSKJr SSKJ r SS/r Sr S r S rS rSS jrS rSSjrg)aThe ``namedutils`` module defines two lightweight container types: :class:`namedtuple` and :class:`namedlist`. Both are subtypes of built-in sequence types, which are very fast and efficient. They simply add named attribute accessors for specific indexes within themselves. The :class:`namedtuple` is identical to the built-in :class:`collections.namedtuple`, with a couple of enhancements, including a ``__repr__`` more suitable to inheritance. The :class:`namedlist` is the mutable counterpart to the :class:`namedtuple`, and is much faster and lighter-weight than full-blown :class:`object`. Consider this if you're implementing nodes in a tree, graph, or other mutable data structure. If you want an even skinnier approach, you'll probably have to look to C. N) OrderedDict) iskeyword) itemgetter namedlist namedtuplez {name}=%rzP {name} = _property(_itemgetter({index:d}), doc='Alias for field {index:d}') zh {name} = _property(_itemgetter({index:d}), _itemsetter({index:d}), doc='Alias for field {index:d}') aclass {typename}(tuple): '{typename}({arg_list})' __slots__ = () _fields = {field_names!r} def __new__(_cls, {arg_list}): # TODO: tweak sig to make more extensible 'Create new instance of {typename}({arg_list})' return _tuple.__new__(_cls, ({arg_list})) @classmethod def _make(cls, iterable, new=_tuple.__new__, len=len): 'Make a new {typename} object from a sequence or iterable' result = new(cls, iterable) if len(result) != {num_fields:d}: raise TypeError('Expected {num_fields:d}' ' arguments, got %d' % len(result)) return result def __repr__(self): 'Return a nicely formatted representation string' tmpl = self.__class__.__name__ + '({repr_fmt})' return tmpl % 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 {typename} object replacing field(s) with new values' result = _self._make(map(kwds.pop, {field_names!r}, _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' # wat pass {field_defs} cV[U[5(a URSS5R5nUVs/sHn[U5PM nnU(a[ 5n[ U5H~upg[ SU55(aJ[U5(d:U(a3USR5(dURS5(dXu;aSU-X'URU5 M U/U-Hln[ SU55(d[SU-5e[U5(a[S U-5eUSR5(dM`[S U-5e [ 5nUHRnURS5(aU(d[S U-5eXu;a[S U-5eURU5 MT S U0n[U5US'[U5US'[[U55RSS5SSUS'SRSU55US'SRS[ U555US'[ R""S!0UD6n U(a [%U 5 ['[(SU-[*[,[S9n [/X5 Xn [4R6"S5n U R8R;SS 5U lU $s snf![0a n [1U R2S-U -5eSn A ff=f![>[4a U $f=f)"aReturns 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 pos 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) , c3X# UH oR5=(d US:Hv M" g7f_Nisalnum.0cs 2lib/python3.13/site-packages/boltons/namedutils.py namedtuple.. >A /qCx/(*rr _%dc3X# UH oR5=(d US:Hv M" g7fr rrs rrr 9Dq99;*!s(*DrWType names and field names can only contain alphanumeric characters and underscores: %r2Type names and field names cannot be a keyword: %r9Type names and field names cannot start with a number: %r/Field names cannot start with an underscore: %r$Encountered duplicate field name: %rtypename field_names num_fields'arg_list, c3H# UHn[RUS9v M g7f)nameN _repr_tmplformatrr+s rrr%#>>>d##7??$$??3''<%*U] " HHTN2 [(9D999K#$% % d  +-123 3 7??  ,.234 4) 5D ??3  "$()* * <CdJK K  ( #F!+.F={+F<eK0199#rB1RHF:#>> Point = namedlist('Point', ['x', 'y']) >>> Point.__doc__ # docstring for the new class 'Point(x, y)' >>> p = Point(11, y=22) # instantiate with pos args or keywords >>> p[0] + p[1] # indexable like a plain list 33 >>> x, y = p # unpack like a regular list >>> 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) r r c3X# UH oR5=(d US:Hv M" g7fr rrs rrnamedlist..9rrrr rc3X# UH oR5=(d US:Hv M" g7fr rrs rrrkBrrrrrrrr r!r"r#r$r%r&r'r(c3H# UHn[RUS9v M g7fr*r,r/s rrrkZr0r1r2r3c3L# UHup[RXS9v M g7fr5) _m_field_tmplr.r8s rrrk\s(%P8N&3%9%9%9%Q8Nr9r:c^U4SjnU$)Nc>XT'g)NrA)objvaluekeys r _itemsetter3namedlist.._itemsetter.._itemsetterds HrA)rtrus` rrunamedlist.._itemsettercs rwz namedlist_%s)r;rur<rr=_listr?Nr<r@rA)!rBrCrDrErFrGrHrIrJrKrLrMrNrOrPrQ_namedlist_tmplr.rSrTr;rrUlistrVrWrXrYrZr[r\r]r^)r r!r_r`rarbr6r+rcrdrurerfrgrhs rrrs%2+s##!))#s399; #./;a3q6;K/ u$[1KE>>>>d##7??$$??3''<%*U] " HHTN2 [(9D999K#$% % d  +-123 3 7??  ,.234 4) 5D ??3  "$()* * <CdJK K  ( #F!+.F={+F<eK0199#rB1RHF:#rsW>$#+.  %  0d`N5pgrw