IMa$@sdZddddddddd g Zd d lTd d lZeej7Zd d lmZmZd dlm Z d d l Z d d l Zd dlmZd dlmZmZmZd dlmZyd dlmZWnek rYnXej eyd dlm!Z!Wnek r"YnXGddde"Z#Gddde$Z%Gddde&Z'Gddde(Z)Gddde*Z+yd dlm+Z+Wnek rYnXdZ,dZ-d Z.d!d!d"dZ/d#d$Z0yd d%lm0Z0Wnek rYnXGd&dde*Z1Gd'd d e2Z3Gd(dde2Z4Gd)ddeZ5Gd*dde6Z7d S)+a?This module implements specialized container datatypes providing alternatives to Python's general purpose built-in containers, dict, list, set, and tuple. * namedtuple factory function for creating tuple subclasses with named fields * deque list-like container with fast appends and pops on either end * ChainMap dict-like class for creating a single view of multiple mappings * Counter dict subclass for counting hashable objects * OrderedDict dict subclass that remembers the order entries were added * defaultdict dict subclass that calls a factory function to supply missing values * UserDict wrapper around dictionary objects for easier dict subclassing * UserList wrapper around list objects for easier list subclassing * UserString wrapper around string objects for easier string subclassing deque defaultdict namedtupleUserDictUserList UserStringCounter OrderedDictChainMap)*N) itemgettereq) iskeyword)proxy)repeatchainstarmap)recursive_repr)r)rc@seZdZddZdS)_OrderedDictKeysViewccst|jEdHdS)N)reversed_mapping)selfr9/opt/alt/python35/lib64/python3.5/collections/__init__.py __reversed__5sz!_OrderedDictKeysView.__reversed__N)__name__ __module__ __qualname__rrrrrr3s rc@seZdZddZdS)_OrderedDictItemsViewccs0x)t|jD]}||j|fVqWdS)N)rr)rkeyrrrr:sz"_OrderedDictItemsView.__reversed__N)rrrrrrrrr8s rc@seZdZddZdS)_OrderedDictValuesViewccs*x#t|jD]}|j|VqWdS)N)rr)rrrrrr@sz#_OrderedDictValuesView.__reversed__N)rrrrrrrrr >s r c@seZdZdZdS)_Linkprevnextr __weakref__N)r"r#rr$)rrr __slots__rrrrr!Ds r!c@sIeZdZdZddZejeeddZej ddZ dd Z d d Z d d Z dddZ dddZddZejZZddZddZddZejZeZeddZdddZed d!Zd"d#Zd$d%Zedd&d'Z d(d)Z!dS)*rz)Dictionary that remembers insertion orderc Os|std|^}}t|dkrFtdt|y |jWnMtk rt|_t|j|_}||_|_i|_ YnX|j ||dS)zInitialize an ordered dictionary. The signature is the same as regular dictionaries, but keyword arguments are not recommended because their insertion order is arbitrary. z?descriptor '__init__' of 'OrderedDict' object needs an argumentz$expected at most 1 arguments, got %dN) TypeErrorlen_OrderedDict__rootAttributeErrorr!_OrderedDict__hardroot_proxyr"r#_OrderedDict__map_OrderedDict__update)argskwdsrrootrrr__init__Vs     zOrderedDict.__init__c Cs{||krg||j|<}|j}|j}||||_|_|_||_|||_||||dS)z!od.__setitem__(i, y) <==> od[i]=yN)r-r)r"r#r) rrvalueZ dict_setitemrZLinklinkr1lastrrr __setitem__ks    zOrderedDict.__setitem__cCsY||||jj|}|j}|j}||_||_d|_d|_dS)z od.__delitem__(y) <==> del od[y]N)r-popr"r#)rrZ dict_delitemr4 link_prev link_nextrrr __delitem__ys      zOrderedDict.__delitem__ccs:|j}|j}x!||k r5|jV|j}qWdS)zod.__iter__() <==> iter(od)N)r)r#r)rr1currrrr__iter__s   zOrderedDict.__iter__ccs:|j}|j}x!||k r5|jV|j}qWdS)z#od.__reversed__() <==> reversed(od)N)r)r"r)rr1r;rrrrs   zOrderedDict.__reversed__cCs7|j}||_|_|jjtj|dS)z.od.clear() -> None. Remove all items from od.N)r)r"r#r-cleardict)rr1rrrr=s  zOrderedDict.clearTcCs|std|j}|rH|j}|j}||_||_n$|j}|j}||_||_|j}|j|=tj||}||fS)zod.popitem() -> (k, v), return and remove a (key, value) pair. Pairs are returned in LIFO order if last is true or FIFO order if false. zdictionary is empty)KeyErrorr)r"r#rr-r>r7)rr5r1r4r8r9rr3rrrpopitems             zOrderedDict.popitemc Cs|j|}|j}|j}|j}||_||_|j}|ry|j}||_||_||_||_n-|j}||_||_||_||_dS)zMove an existing element to the end (or beginning if last==False). Raises KeyError if the element does not exist. When last=True, acts like a fast version of self[key]=self.pop(key). N)r-r"r#r)) rrr5r4r8r9Z soft_linkr1firstrrr move_to_ends$                zOrderedDict.move_to_endcCsqtj}t|d}||j}|||jd7}|||j|7}|||j|7}|S)Nr&)_sys getsizeofr(__dict__r-r+r))rZsizeofnsizerrr __sizeof__s zOrderedDict.__sizeof__cCs t|S)z:D.keys() -> a set-like object providing a view on D's keys)r)rrrrkeysszOrderedDict.keyscCs t|S)z a set-like object providing a view on D's items)r)rrrritemsszOrderedDict.itemscCs t|S)z6D.values() -> an object providing a view on D's values)r )rrrrvaluesszOrderedDict.valuescCs@||kr!||}||=|S||jkr<t||S)zod.pop(k[,d]) -> v, remove specified key and return the corresponding value. If key is not found, d is returned if given, otherwise KeyError is raised. )_OrderedDict__markerr?)rrdefaultresultrrrr7s   zOrderedDict.popNcCs"||kr||S|||<|S)zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr)rrrNrrr setdefaults  zOrderedDict.setdefaultcCs7|sd|jjfSd|jjt|jfS)zod.__repr__() <==> repr(od)z%s()z%s(%r)) __class__rlistrK)rrrr__repr__szOrderedDict.__repr__cCsdt|j}x'ttD]}|j|dq"W|jf|pNddt|jfS)z%Return state information for picklingN)varscopyrr7rQiterrK)rZ inst_dictkrrr __reduce__szOrderedDict.__reduce__cCs |j|S)z!od.copy() -> a shallow copy of od)rQ)rrrrrUszOrderedDict.copycCs(|}x|D]}||| New ordered dictionary with keys from S. If not specified, the value defaults to None. r)clsiterabler3rrrrrfromkeyss  zOrderedDict.fromkeyscCsGt|tr7tj||o6ttt||Stj||S)zod.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive while comparison to a regular mapping is order-insensitive. ) isinstancerr>__eq__allmap_eq)rotherrrrr]s(zOrderedDict.__eq__)"rrr__doc__r2r>r6r,r!r:r<rr=r@rBrIMutableMappingupdater.rJrKrL__ne__objectrMr7rP_recursive_reprrSrXrU classmethodr[r]rrrrrGs0             )rafrom builtins import property as _property, tuple as _tuple from operator import itemgetter as _itemgetter from collections import OrderedDict class {typename}(tuple): '{typename}({arg_list})' __slots__ = () _fields = {field_names!r} def __new__(_cls, {arg_list}): '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 _replace(_self, **kwds): 'Return a new {typename} object replacing specified fields with new values' result = _self._make(map(kwds.pop, {field_names!r}, _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__ + '({repr_fmt})' % 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) {field_defs} z {name}=%rzW {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}') Fc Cst|tr'|jddj}ttt|}t|}|rt}xit|D][\}}|j st |s|j ds||krd|||<|j |qdWxk|g|D]\}t |tkrt d|jstd|t |rtd|qWt}x]|D]U}|j drm| rmtd|||krtd ||j |qAWtjd |d t|d t|d tt|jddddddjdd|Dddjddt|D}tdd|}t||||} || _|rpt| jy%tjdjjdd| _Wnttfk rYnX| S)aCReturns 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) , _z_%dz*Type names and field names must be stringsz8Type names and field names must be valid identifiers: %rz2Type names and field names cannot be a keyword: %rz/Field names cannot start with an underscore: %rz$Encountered duplicate field name: %rtypename field_names num_fieldsarg_list'r&repr_fmtz, css!|]}tjd|VqdS)nameN)_repr_templateformat).0rsrrr sznamedtuple.. field_defs css-|]#\}}tjd|d|VqdS)indexrsN)_field_templateru)rvrzrsrrrrwsrz namedtuple_%s__main__)r\strreplacesplitrRr_set enumerate isidentifier _iskeyword startswithaddtyper' ValueError_class_templaterutupler(reprjoinr>exec_sourceprintrD _getframe f_globalsgetrr*) rlrmverboserenameseenrzrsclass_definition namespacerOrrrrgsd                (     %cCs5|j}x%|D]}||dd||>> c = Counter('abcdeabcdabcaba') # count elements from a string >>> c.most_common(3) # three most common elements [('a', 5), ('b', 4), ('c', 3)] >>> sorted(c) # list all unique elements ['a', 'b', 'c', 'd', 'e'] >>> ''.join(sorted(c.elements())) # list elements with repetitions 'aaaaabbbbcccdde' >>> sum(c.values()) # total of all counts 15 >>> c['a'] # count of letter 'a' 5 >>> for elem in 'shazam': # update counts from an iterable ... c[elem] += 1 # by adding 1 to each element's count >>> c['a'] # now there are seven 'a' 7 >>> del c['b'] # remove all 'b' >>> c['b'] # now there are zero 'b' 0 >>> d = Counter('simsalabim') # make another counter >>> c.update(d) # add in the second counter >>> c['a'] # now there are nine 'a' 9 >>> c.clear() # empty the counter >>> c Counter() Note: If a count is set to zero or reduced to zero, it will remain in the counter until the entry is deleted or the counter is cleared: >>> c = Counter('aaabbc') >>> c['b'] -= 2 # reduce the count of 'b' by two >>> c.most_common() # 'b' is still in, but its count is zero [('a', 3), ('c', 1), ('b', 0)] csm|std|^}}t|dkrFtdt|tt|j|j||dS)a Create a new, empty Counter object. And if given, count elements from an input iterable. Or, initialize the count from another mapping of elements to their counts. >>> c = Counter() # a new, empty counter >>> c = Counter('gallahad') # a new counter from an iterable >>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping >>> c = Counter(a=4, b=2) # a new counter from keyword args z;descriptor '__init__' of 'Counter' object needs an argumentr&z$expected at most 1 arguments, got %dN)r'r(superrr2rd)r/r0r)rQrrr2s   zCounter.__init__cCsdS)z1The count of elements not in the Counter is zero.r r)rrrrr __missing__szCounter.__missing__NcCsP|dkr.t|jdtdddStj||jdtdS)zList the n most common elements and their counts from the most common to the least. If n is None, then list all element counts. >>> Counter('abcdeabcdabcaba').most_common(3) [('a', 5), ('b', 4), ('c', 3)] Nrr&reverseT)sortedrK _itemgetter_heapqnlargest)rrGrrr most_commons "zCounter.most_commoncCstjtt|jS)aIterator over elements repeating each as many times as its count. >>> c = Counter('ABCABC') >>> sorted(c.elements()) ['A', 'A', 'B', 'B', 'C', 'C'] # Knuth's example for prime factors of 1836: 2**2 * 3**3 * 17**1 >>> prime_factors = Counter({2: 2, 3: 3, 17: 1}) >>> product = 1 >>> for factor in prime_factors.elements(): # loop over factors ... product *= factor # and multiply them >>> product 1836 Note, if an element's count has been set to zero or is a negative number, elements() will ignore it. )_chain from_iterable_starmap_repeatrK)rrrrelements)szCounter.elementscCstddS)Nz@Counter.fromkeys() is undefined. Use Counter(iterable) instead.)NotImplementedError)rYrZvrrrr[AszCounter.fromkeyscs|std|^}}t|dkrFtdt||rV|dnd}|dk rt|tr|r|j}xJ|jD]#\}}|||d||>> c = Counter('which') >>> c.update('witch') # add elements from another iterable >>> d = Counter('watch') >>> c.update(d) # add elements from another counter >>> c['h'] # four 'h' in which, witch, and watch 4 z9descriptor 'update' of 'Counter' object needs an argumentr&z$expected at most 1 arguments, got %dr N) r'r(r\MappingrrKrrrdr)r/r0rrZself_getrcount)rQrrrdHs      zCounter.updatecOs|std|^}}t|dkrFtdt||rV|dnd}|dk r|j}t|trx\|jD]#\}}||d|||>> c = Counter('which') >>> c.subtract('witch') # subtract elements from another iterable >>> c.subtract(Counter('watch')) # subtract elements from another counter >>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch 0 >>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch -1 z;descriptor 'subtract' of 'Counter' object needs an argumentr&z$expected at most 1 arguments, got %dr N)r'r(rr\rrKsubtract)r/r0rrZrrrrrrrps     zCounter.subtractcCs |j|S)zReturn a shallow copy.)rQ)rrrrrUsz Counter.copycCs|jt|ffS)N)rQr>)rrrrrXszCounter.__reduce__cs ||krtj|dS)zGLike dict.__delitem__() but does not raise KeyError for missing values.N)rr:)rr)rQrrr:s zCounter.__delitem__c Cs|sd|jjSy9djtdj|j}d|jj|fSWn.tk r}dj|jjt|SYnXdS)Nz%s()z, z%r: %rz%s({%s})z {0}({1!r})) rQrrr___mod__rr'rur>)rrKrrrrSs! zCounter.__repr__cCst|tstSt}x>|jD]0\}}|||}|dkr)|||>> Counter('abbb') + Counter('bcc') Counter({'b': 4, 'c': 2, 'a': 1}) r )r\rNotImplementedrK)rrarOrrnewcountrrr__add__s  zCounter.__add__cCst|tstSt}x>|jD]0\}}|||}|dkr)|||>> Counter('abbbc') - Counter('bccd') Counter({'b': 2, 'a': 1}) r )r\rrrK)rrarOrrrrrr__sub__s  zCounter.__sub__cCst|tstSt}xR|jD]D\}}||}||krQ|n|}|dkr)|||>> Counter('abbb') | Counter('bcc') Counter({'b': 3, 'c': 2, 'a': 1}) r )r\rrrK)rrarOrr other_countrrrr__or__s   zCounter.__or__cCsut|tstSt}xR|jD]D\}}||}||krQ|n|}|dkr)|||>> Counter('abbb') & Counter('bcc') Counter({'b': 1}) r )r\rrrK)rrarOrrrrrrr__and__s   zCounter.__and__cCs@t}x0|jD]"\}}|dkr|||s z*Counter._keep_positive..)rK)r nonpositiverrrr_keep_positives  zCounter._keep_positivecCs5x(|jD]\}}|||7>> c = Counter('abbb') >>> c += Counter('bcc') >>> c Counter({'b': 4, 'c': 2, 'a': 1}) )rKr)rrarrrrr__iadd__s zCounter.__iadd__cCs5x(|jD]\}}|||8>> c = Counter('abbbc') >>> c -= Counter('bccd') >>> c Counter({'b': 2, 'a': 1}) )rKr)rrarrrrr__isub__#s zCounter.__isub__cCsGx:|jD],\}}||}||kr |||>> c = Counter('abbb') >>> c |= Counter('bcc') >>> c Counter({'b': 3, 'c': 2, 'a': 1}) )rKr)rrarrrrrr__ior__0s   zCounter.__ior__cCsGx:|jD],\}}||}||kr |||>> c = Counter('abbb') >>> c &= Counter('bcc') >>> c Counter({'b': 1}) )rKr)rrarrrrrr__iand__?s   zCounter.__iand__)rrrrbr2rrrrhr[rdrrUrXr:rSrrrrrrrrrrrrr)rQrrs0 +  ( "          c@seZdZdZddZddZddZdd d Zd d Zd dZ ddZ ddZ e ddZ eddZddZeZdddZeddZddZdd Zd!d"Zd#d$Zd%d&ZdS)'r a A ChainMap groups multiple dicts (or other mappings) together to create a single, updateable view. The underlying mappings are stored in a list. That list is public and can be accessed or updated using the *maps* attribute. There is no other state. Lookups search the underlying mappings successively until a key is found. In contrast, writes, updates, and deletions only operate on the first mapping. cGst|pig|_dS)zInitialize a ChainMap by setting *maps* to the given mappings. If no mappings are provided, a single empty dictionary is used. N)rRmaps)rrrrrr2aszChainMap.__init__cCst|dS)N)r?)rrrrrrhszChainMap.__missing__c CsBx2|jD]'}y ||SWq tk r0Yq Xq W|j|S)N)rr?r)rrrrrr __getitem__ks    zChainMap.__getitem__NcCs||kr||S|S)Nr)rrrNrrrrssz ChainMap.getcCsttj|jS)N)r(runionr)rrrr__len__vszChainMap.__len__cCsttj|jS)N)rVrrr)rrrrr<yszChainMap.__iter__cs tfdd|jDS)Nc3s|]}|kVqdS)Nr)rvm)rrrrw}sz(ChainMap.__contains__..)anyr)rrr)rr __contains__|szChainMap.__contains__cCs t|jS)N)rr)rrrr__bool__szChainMap.__bool__cCs%dj|djtt|jS)Nz{0.__class__.__name__}({1})z, )rurr_rr)rrrrrSszChainMap.__repr__cGs|tj||S)z?Create a ChainMap with a single dict created from the iterable.)r>r[)rYrZr/rrrr[szChainMap.fromkeyscCs*|j|jdj|jddS)zHNew ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]r r&N)rQrrU)rrrrrUsz ChainMap.copycCs%|dkri}|j||jS)zyNew ChainMap with a new map followed by all previous maps. If no map is provided, an empty dict is used. N)rQr)rrrrr new_childs zChainMap.new_childcCs|j|jddS)zNew ChainMap from maps[1:].r&N)rQr)rrrrparentsszChainMap.parentscCs||jd|z0Passing 'dict' as keyword argument is deprecated stacklevelrC)r'r(r7warningswarnPendingDeprecationWarningdatard)r/kwargsrr>rrrrr2s$          zUserDict.__init__cCs t|jS)N)r(r)rrrrrszUserDict.__len__cCsO||jkr|j|St|jdr?|jj||St|dS)Nr)rhasattrrQrr?)rrrrrrs  zUserDict.__getitem__cCs||j|d,d-Zd.d/Zd0d1Zd2d3Zd4d5Zd6d7Zd8d9Zd:d;Z d<d=Z!dS)?rzAA more or less complete user-defined wrapper around list objects.NcCsg|_|dk rt|t|jkrF||jddsz UserList.sortcCs9t|tr%|jj|jn|jj|dS)N)r\rrextend)rrarrrr?szUserList.extendr})"rrrrbr2rSrrr]rrrrrrr6r:rrrr__rmul__rrrr7rr=rUrrzrrrrrrrrs>                           c@seZdZddZddZddZddZd d Zd d Zd dZ ddZ ddZ ddZ ddZ ddZddZddZddZdd Zd!d"Zd#d$Zd%d&ZeZd'd(Zd)d*Zd+d,Zd-d.Zd/d0Zd1ejd2d3Zd4d4d5d6Zd1ejd7d8Z d9d:d;Z!d1ejd<d=Z"d>d?Z#d@dAZ$d1ejdBdCZ%dDdEZ&dFdGZ'dHdIZ(dJdKZ)dLdMZ*dNdOZ+dPdQZ,dRdSZ-dTdUZ.dVdWZ/dXdYZ0dZd[Z1d\d]Z2d^d_Z3d4d`daZ4e5j6Z6dbdcZ7ddedfZ8d1ejdgdhZ9d1ejdidjZ:dkdlZ;dmdnZ<d4dodpZ=d4ddqdrZ>d4ddsdtZ?dudvdwZ@d1ejdxdyZAd4dzd{ZBd|d}ZCd~dZDddZEddZFddZGd4S)rcCsVt|tr||_n7t|trC|jdd|_nt||_dS)N)r\r~rr)rseqrrrr2Ls  zUserString.__init__cCs t|jS)N)r~r)rrrr__str__SszUserString.__str__cCs t|jS)N)rr)rrrrrSTszUserString.__repr__cCs t|jS)N)intr)rrrr__int__UszUserString.__int__cCs t|jS)N)floatr)rrrr __float__VszUserString.__float__cCs t|jS)N)complexr)rrrr __complex__WszUserString.__complex__cCs t|jS)N)hashr)rrrr__hash__XszUserString.__hash__cCs|jddfS)N)r)rrrr__getnewargs__YszUserString.__getnewargs__cCs,t|tr|j|jkS|j|kS)N)r\rr)rstringrrrr]\szUserString.__eq__cCs,t|tr|j|jkS|j|kS)N)r\rr)rrrrrr`szUserString.__lt__cCs,t|tr|j|jkS|j|kS)N)r\rr)rrrrrrdszUserString.__le__cCs,t|tr|j|jkS|j|kS)N)r\rr)rrrrrrhszUserString.__gt__cCs,t|tr|j|jkS|j|kS)N)r\rr)rrrrrrlszUserString.__ge__cCs%t|tr|j}||jkS)N)r\rr)rcharrrrrqs zUserString.__contains__cCs t|jS)N)r(r)rrrrrvszUserString.__len__cCs|j|j|S)N)rQr)rrzrrrrwszUserString.__getitem__cCsct|tr&|j|j|jSt|trI|j|j|S|j|jt|S)N)r\rrQrr~)rrarrrrxs zUserString.__add__cCs=t|tr#|j||jS|jt||jS)N)r\r~rQr)rrarrrr~szUserString.__radd__cCs|j|j|S)N)rQr)rrGrrrrszUserString.__mul__cCs|j|j|S)N)rQr)rr/rrrrszUserString.__mod__cCs|j|tS)N)rQr/)rrurrr__rmod__szUserString.__rmod__cCs|j|jjS)N)rQr capitalize)rrrrrszUserString.capitalizecCs|j|jjS)N)rQrcasefold)rrrrrszUserString.casefoldcGs|j|jj||S)N)rQrcenter)rwidthr/rrrrszUserString.centerr cCs.t|tr|j}|jj|||S)N)r\rrr)rsubstartendrrrrs zUserString.countNcCsW|rA|r(|j|jj||S|j|jj|S|j|jjS)N)rQrencode)rencodingerrorsrrrrs zUserString.encodecCs|jj|||S)N)rendswith)rsuffixrrrrrrszUserString.endswithcCs|j|jj|S)N)rQr expandtabs)rtabsizerrrrszUserString.expandtabscCs.t|tr|j}|jj|||S)N)r\rrfind)rrrrrrrrs zUserString.findcOs|jj||S)N)rru)rr/r0rrrruszUserString.formatcCs|jj|S)N)r format_map)rrrrrrszUserString.format_mapcCs|jj|||S)N)rrz)rrrrrrrrzszUserString.indexcCs |jjS)N)risalpha)rrrrrszUserString.isalphacCs |jjS)N)risalnum)rrrrrszUserString.isalnumcCs |jjS)N)r isdecimal)rrrrrszUserString.isdecimalcCs |jjS)N)risdigit)rrrrrszUserString.isdigitcCs |jjS)N)rr)rrrrrszUserString.isidentifiercCs |jjS)N)rislower)rrrrr szUserString.islowercCs |jjS)N)r isnumeric)rrrrr szUserString.isnumericcCs |jjS)N)r isprintable)rrrrr szUserString.isprintablecCs |jjS)N)risspace)rrrrr szUserString.isspacecCs |jjS)N)ristitle)rrrrr szUserString.istitlecCs |jjS)N)risupper)rrrrrszUserString.isuppercCs|jj|S)N)rr)rrrrrrszUserString.joincGs|j|jj||S)N)rQrljust)rrr/rrrrszUserString.ljustcCs|j|jjS)N)rQrlower)rrrrrszUserString.lowercCs|j|jj|S)N)rQrlstrip)rcharsrrrrszUserString.lstripcCs|jj|S)N)r partition)rseprrrrszUserString.partitionr&cCsOt|tr|j}t|tr0|j}|j|jj|||S)N)r\rrrQr)roldnewmaxsplitrrrrs   zUserString.replacecCs.t|tr|j}|jj|||S)N)r\rrrfind)rrrrrrrrs zUserString.rfindcCs|jj|||S)N)rrindex)rrrrrrrrszUserString.rindexcGs|j|jj||S)N)rQrrjust)rrr/rrrrszUserString.rjustcCs|jj|S)N)r rpartition)rrrrrrszUserString.rpartitioncCs|j|jj|S)N)rQrrstrip)rrrrrrszUserString.rstripcCs|jj||S)N)rr)rrrrrrrszUserString.splitcCs|jj||S)N)rrsplit)rrrrrrrszUserString.rsplitFcCs|jj|S)N)r splitlines)rkeependsrrrrszUserString.splitlinescCs|jj|||S)N)rr)rprefixrrrrrrszUserString.startswithcCs|j|jj|S)N)rQrstrip)rrrrrr!szUserString.stripcCs|j|jjS)N)rQrswapcase)rrrrr"szUserString.swapcasecCs|j|jjS)N)rQrtitle)rrrrr#szUserString.titlecGs|j|jj|S)N)rQr translate)rr/rrrr$szUserString.translatecCs|j|jjS)N)rQrupper)rrrrr%szUserString.uppercCs|j|jj|S)N)rQrzfill)rrrrrr&szUserString.zfillr}r}r})Hrrrr2rrSrrrrrr]rrrrrrrrrrrrrrrrrDmaxsizerrrrrrurrzrrrrrr r r r r rrrrrr~ maketransrrrrrrrrrrrr!r"r#r$r%r&rrrrrKs                                                 )8rb__all___collections_abcoperatorr rr r`keywordrrsysrDheapqr_weakrefrr, itertoolsrrrrrrreprlibrrg _collectionsr ImportErrorMutableSequenceregisterrKeysViewr ItemsViewr ValuesViewr rfr!r>rrrtr{rrrrcr rrSequencerrrrrsZ         3^  lCI