Vi<SrSSKJr SSKrSSKJr SSK J r SSK J r \ SrS S /rS rS rS rSrSSjrSrSSjrg!\a \rN5f=f!\a \\4rSrN6f=f)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. )print_functionN) OrderedDict) iskeyword) itemgetterc[S5 g)Nzexec code in global_envexeccode global_envs e/home/james-whalen/.local/share/pipx/venvs/semgrep/lib/python3.13/site-packages/boltons/namedutils.pyexec_r?s  &'c[X5 gNrr s r rrCs  Tr 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'SR!SU55US'SR!S[ U555US'["R$"S!0UD6n U(a ['U 5 [)[*SU-[,[.[S9n [1X5 Xn [6R8"S5n U R:R=SS 5U lU $s snf![2a n [3U R4S-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 r namedtuple.. >A /qCx/(*rr_%dc3X# UH oR5=(d US:Hv M" g7frrrs r rr 9Dq99;*!s(*Dr"WType 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_tmplformatrr6s r rr %#>>>d##7??$$??3''<%*U] " HHTN2 [(9D999K#$% % d  +-123 3 7??  ,.234 4) 5D ??3  "$()* * <CdJK K  ( #F!+.F={+F<eK0199#rB1RHF:#>??@ J '  M s/K" K')7L' L1L  LL('L(aclass {typename}(list): '{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 _list.__new__(_cls, ({arg_list})) def __init__(self, {arg_list}): # tuple didn't need this but list does return _list.__init__(self, ({arg_list})) @classmethod def _make(cls, iterable, new=_list, len=len): 'Make a new {typename} object from a sequence or iterable' # why did this function exist? why not just star the # iterable like below? result = 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 % tuple(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 list. Used by copy and pickle.' return tuple(self) __dict__ = _property(_asdict) def __getstate__(self): 'Exclude the OrderedDict from pickling' # wat pass {field_defs} c ^[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'SR!SU55US'SR!S[ U555US'["R$"S"0UD6n U(a ['U 5 Sn [)[*U SU-[,[.[0S9n [3X5 Xn [8R:"S5nUR<R?S S!5U l U $s snf![4a n [5U R6S-U -5eSn A ff=f![B[4a U $f=f)#aReturns a new subclass of list with named fields. >>> 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) rrc3X# UH oR5=(d US:Hv M" g7frrrs r rnamedlist..Hr!r"rrr#c3X# UH oR5=(d US:Hv M" g7frrrs r rrvQr%r"r&r'r(r)r*r+r,r-r.r/r0r1r2r3c3H# UHn[RUS9v M g7fr5r7r:s r rrvir;r<r=r>c3L# UHup[RXS9v M g7fr@) _m_field_tmplr9rCs r rrvks(%P8N&3%9%9%9%Q8NrDrEc^U4SjnU$)Nc>XT'grrL)objvaluekeys r _itemsetter3namedlist.._itemsetter.._itemsetterss HrrL)rrs` r rnamedlist.._itemsetterrs rz namedlist_%s)rFrrGrrH_listrJNrGrKrL)"rMrNrOrPrQrRrSrTrUrVrWrXrYrZr[r\r]_namedlist_tmplr9r_r`rFrralistrrbrcrdrerfrgrhri)r+r,rjrkrlrmrAr6rnrorrprqrrrss r rr)s)2+z**!))#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:#>??@ J '  M s/K& K+-7L+ L5LLL,+L,)FF)__doc__ __future__rsysrd collectionsr ImportErrorr`keywordrrUoperatorrrFrNr NameErrorrQbytes__all__r8rBrzr^rrrrLrr rsB"&',.(  %  0d`N5pgeKuJs ?A A  A  AA