j fv @ s d d d d d d d d d g Z d d
l Td d l Z e e j 7Z d d l m Z m Z d d
l m Z m Z d d l
m Z d d l
Z d d l Z d d l m Z d d l m Z m Z m Z d d l m Z Gd d d e Z Gd d d e Z! d Z" d Z# d Z$ d d d d Z% d d Z& y d d l m& Z& Wn e' k
rXYn XGd d d e Z( Gd d d e) Z* Gd d d e) Z+ Gd d d e, Z- Gd! d d e. Z/ d S)"deque defaultdict
namedtupleUserDictUserList
UserStringCounter OrderedDictChainMap )*N)r r )
itemgettereq) iskeyword)proxy)repeatchainstarmap)recursive_reprc @ s e Z d Z d Z d S)_Linkprevnextkey __weakref__N)zprevznextzkeyz __weakref__)__name__
__module__ __qualname__ __slots__ r r 9/opt/alt/python34/lib64/python3.4/collections/__init__.pyr s r c @ s@ e Z d Z d Z d d Z e j e e d d Z e j d d Z d d Z
d
d Z d d
Z d d d Z
d d d Z d d Z e j Z Z e j Z e j Z e j Z e j Z e Z e d d Z d d d Z e d d Z d d Z d d Z e d d d! Z d" d# Z! d S)$r z)Dictionary that remembers insertion orderc O s | s t d n | ^ } } t | d k rL t d t | n y | j WnM t k
r t | _ t | j | _ } | | _ | _ i | _ Yn X| j
| | d S)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 argument z$expected at most 1 arguments, got %dN) TypeErrorlen_OrderedDict__rootAttributeErrorr _OrderedDict__hardroot_proxyr r _OrderedDict__map_OrderedDict__update)argskwdsselfrootr r r __init__) s
zOrderedDict.__init__c C s~ | | k rj | | j | <} | j } | j } | | | | _ | _ | _ | | _ | | | _ n | | | | d S)z!od.__setitem__(i, y) <==> od[i]=yN)r& r" r r r ) r* r value dict_setitemr Linklinkr+ lastr r r __setitem__> s zOrderedDict.__setitem__c C sG | | | | j j | } | j } | j } | | _ | | _ d S)z od.__delitem__(y) <==> del od[y]N)r& popr r )r* r dict_delitemr0 link_prev link_nextr r r __delitem__L s
zOrderedDict.__delitem__c c s: | j } | j } x! | | k r5 | j V| j } q Wd S)zod.__iter__() <==> iter(od)N)r" r r )r* r+ currr r r __iter__W s
zOrderedDict.__iter__c c s: | j } | j } x! | | k r5 | j V| j } q Wd S)z#od.__reversed__() <==> reversed(od)N)r" r r )r* r+ r8 r r r __reversed__` s
zOrderedDict.__reversed__c C s7 | j } | | _ | _ | j j t j | d S)z.od.clear() -> None. Remove all items from od.N)r" r r r& cleardict)r* r+ r r r r; i s
zOrderedDict.clearTc C s | s t d n | j } | rK | j } | j } | | _ | | _ n$ | j } | j } | | _ | | _ | j } | j | =t j | | } | | f S)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 r r& r< r3 )r* r1 r+ r0 r5 r6 r r- r r r popitemp s
zOrderedDict.popitemc C s | j | } | j } | j } | | _ | | _ | j } | rn | j } | | _ | | _ | | _ | _ n+ | j } | | _ | | _ | | _ | _ d S)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" )r* r r1 r0 r5 r6 r+ firstr r r move_to_end s
zOrderedDict.move_to_endc C sq t j } t | d } | | j } | | | j d 7} | | | j | 7} | | | j | 7} | S)Nr )_sys getsizeofr! __dict__r& r$ r" )r* sizeofnsizer r r
__sizeof__ s zOrderedDict.__sizeof__c C sC | | k r! | | } | | =| S| | j k r? t | n | 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= )r* r defaultresultr r r r3 s
zOrderedDict.popNc C s" | | k r | | S| | | <| S)zDod.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in odr )r* r rJ r r r
setdefault s
zOrderedDict.setdefaultc C s7 | s d | j j f Sd | j j t | j f S)zod.__repr__() <==> repr(od)z%s()z%s(%r)) __class__r listitems)r* r r r __repr__ s zOrderedDict.__repr__c C sd t | j } x' t t D] } | j | d q" W| j f | pN d d t | j f S)z%Return state information for picklingN)varscopyr r3 rM iterrO )r* inst_dictkr r r
__reduce__ s zOrderedDict.__reduce__c C s
| j | S)z!od.copy() -> a shallow copy of od)rM )r* r r r rR s zOrderedDict.copyc C s( | } x | D] } | | | New ordered dictionary with keys from S.
If not specified, the value defaults to None.
r )clsiterabler- r* r r r r fromkeys s
zOrderedDict.fromkeysc C sG t | t r7 t j | | o6 t t t | | St j | | S)zod.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
while comparison to a regular mapping is order-insensitive.
)
isinstancer r< __eq__allmap_eq)r* otherr r r r[ s (zOrderedDict.__eq__)"r r r __doc__r, r< r2 r% r r7 r9 r: r; r> r@ rH MutableMappingupdater' keysvaluesrO __ne__objectrI r3 rL _recursive_reprrP rV rR classmethodrY r[ r r r r r s0
a from 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
C s t | t r* | j d d j } n t t t | } t | } | r t } xo t | D]^ \ } } | j s t | s | j
d s | | k r d | | | >> 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 accessable 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, c s s! | ] } t j d | Vq d S)nameN)_repr_templateformat).0rs r r r c s z namedtuple..
field_defs
c s s- | ]# \ } } t j d | d | Vq d S)indexrs N)_field_templateru )rv rz rs r r r rw e s r z
namedtuple_%s__main__) rZ strreplacesplitrN r] set enumerate isidentifier
_iskeyword
startswithaddtyper
ValueError_class_templateru tupler! reprjoinr< exec_sourceprintrB _getframe f_globalsgetr r# )
rl rm verboserenameseenrz rs class_definition namespacerK r r r r $ sd
(
%c C s5 | j } x% | D] } | | d d | | >> 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)]
c ss | s t d n | ^ } } t | d k rL t d t | n t t | j | j | | d S)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! superr r, rb )r( r) r* )rM r r r, s zCounter.__init__c C s d S)z1The count of elements not in the Counter is zero.r
r )r* r r r r __missing__ s zCounter.__missing__Nc C sP | d k r. t | j d t d d d St j | | j d t d S)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)]
Nr r reverseT)sortedrO _itemgetter_heapqnlargest)r* rF r r r most_common s "zCounter.most_commonc C s t j t t | j S)a Iterator 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_repeatrO )r* r r r elements s zCounter.elementsc C s t d d S)Nz@Counter.fromkeys() is undefined. Use Counter(iterable) instead.)NotImplementedError)rW rX vr r r rY s zCounter.fromkeysc s | s t d n | ^ } } t | d k rL t d t | n | r\ | d n d } | d k r t | t r | r | j } xJ | j D]# \ } } | | | 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! rZ Mappingr rO r r rb r )r( r) r* rX self_getr count)rM r r rb s zCounter.updatec O s | s t d n | ^ } } t | d k rL t d t | n | r\ | d n d } | d k r | j } t | t r x\ | j D]# \ } } | | 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! r rZ r rO subtract)r( r) r* rX r r r r r r r - s
zCounter.subtractc C s
| j | S)zReturn a shallow copy.)rM )r* r r r rR O s z Counter.copyc C s | j t | f f S)N)rM r< )r* r r r rV S s zCounter.__reduce__c s# | | k r t j | n d S)zGLike dict.__delitem__() but does not raise KeyError for missing values.N)r r7 )r* r )rM r r r7 V s zCounter.__delitem__c C s | s d | j j Sy9 d j t d j | j } d | j j | f SWn. t k
r} d j | j j t | SYn Xd S)Nz%s()z, z%r: %rz%s({%s})z
{0}({1!r})) rM r r r] __mod__r r ru r< )r* rO r r r rP [ s !
zCounter.__repr__c C s t | t s t St } xA | j D]3 \ } } | | | } | d k r) | | | >> Counter('abbb') + Counter('bcc')
Counter({'b': 4, 'c': 2, 'a': 1})
r
)rZ r NotImplementedrO )r* r_ rK r r newcountr r r __add__n s zCounter.__add__c C s t | t s t St } xA | j D]3 \ } } | | | } | d k r) | | | >> Counter('abbbc') - Counter('bccd')
Counter({'b': 2, 'a': 1})
r
)rZ r r rO )r* r_ rK r r r r r r __sub__ s zCounter.__sub__c C s t | t s t St } xU | j D]G \ } } | | } | | k rQ | n | } | d k r) | | | >> Counter('abbb') | Counter('bcc')
Counter({'b': 3, 'c': 2, 'a': 1})
r
)rZ r r rO )r* r_ rK r r other_countr r r r __or__ s
zCounter.__or__c C sx t | t s t St } xU | j D]G \ } } | | } | | k rQ | n | } | d k r) | | | >> Counter('abbb') & Counter('bcc')
Counter({'b': 1})
r
)rZ r r rO )r* r_ rK r r r r r r r __and__ s
zCounter.__and__c C s | t S)zEAdds an empty counter, effectively stripping negative and zero counts)r )r* r r r __pos__ s zCounter.__pos__c C s t | S)z{Subtracts from an empty counter. Strips positive and zero counts,
and flips the sign on negative counts.
)r )r* r r r __neg__ s zCounter.__neg__c C s5 d d | j D } x | D]
} | | =q W| S)z?Internal method to strip elements with a negative or zero countc S s( g | ] \ } } | d k s | q S)r
r )rv r r r r r
s z*Counter._keep_positive..)rO )r* nonpositiver r r r _keep_positive s
zCounter._keep_positivec C s5 x( | j D] \ } } | | | 7>> c = Counter('abbb')
>>> c += Counter('bcc')
>>> c
Counter({'b': 4, 'c': 2, 'a': 1})
)rO r )r* r_ r r r r r __iadd__ s zCounter.__iadd__c C s5 x( | j D] \ } } | | | 8>> c = Counter('abbbc')
>>> c -= Counter('bccd')
>>> c
Counter({'b': 2, 'a': 1})
)rO r )r* r_ r r r r r __isub__ s zCounter.__isub__c C sJ x= | j D]/ \ } } | | } | | k r
| | | >> c = Counter('abbb')
>>> c |= Counter('bcc')
>>> c
Counter({'b': 3, 'c': 2, 'a': 1})
)rO r )r* r_ r r r r r r __ior__ s
zCounter.__ior__c C sJ x= | j D]/ \ } } | | } | | k r
| | | >> c = Counter('abbb')
>>> c &= Counter('bcc')
>>> c
Counter({'b': 1})
)rO r )r* r_ r r r r r r __iand__ s
zCounter.__iand__)r r r r` r, r r r rh rY rb r rR rV r7 rP r r r r r r r r r r r r r )rM r r s0 +
( "
c @ s e Z d Z d Z d d Z d d Z d d Z d d d
Z d d Z d
d Z d d Z
d d Z e d d Z
e d d Z d d Z e Z d d d Z e d d Z d d Z d d Z d! d" Z d# d$ Z d% d& Z d S)'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
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.
c G s t | p i g | _ d S)zInitialize a ChainMap by setting *maps* to the given mappings.
If no mappings are provided, a single empty dictionary is used.
N)rN maps)r* r r r r r, s zChainMap.__init__c C s t | d S)N)r= )r* r r r r r s zChainMap.__missing__c C sB x2 | j D]' } y | | SWq
t k
r0 Yq
Xq
W| j | S)N)r r= r )r* r r r r r __getitem__ s
zChainMap.__getitem__Nc C s | | k r | | S| S)Nr )r* r rJ r r r r ' s z ChainMap.getc C s t t j | j S)N)r! r unionr )r* r r r __len__* s zChainMap.__len__c C s t t j | j S)N)rS r r r )r* r r r r9 - s zChainMap.__iter__c s t f d d | j D S)Nc 3 s | ] } | k Vq d S)Nr )rv m)r r r rw 1 s z(ChainMap.__contains__..)anyr )r* r r )r r __contains__0 s zChainMap.__contains__c C s
t | j S)N)r r )r* r r r __bool__3 s zChainMap.__bool__c C s% d j | d j t t | j S)Nz{0.__class__.__name__}({1})z, )ru r r] r r )r* r r r rP 6 s zChainMap.__repr__c G s | t j | | S)z?Create a ChainMap with a single dict created from the iterable.)r< rY )rW rX r( r r r rY ; s zChainMap.fromkeysc C s* | j | j d j | j d d S)zHNew ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]r
r N)rM r rR )r* r r r rR @ s z
ChainMap.copyc C s( | d k r i } n | j | | j S)zyNew ChainMap with a new map followed by all previous maps.
If no map is provided, an empty dict is used.
N)rM r )r* r r r r new_childF s zChainMap.new_childc C s | j | j d d S)zNew ChainMap from maps[1:].r N)rM r )r* r r r parentsN s zChainMap.parentsc C s | | j d | r= )r* r r r r> \ s
zChainMap.popitemc G sI y | j d j | | SWn' t k
rD t d j | Yn Xd S)zWRemove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].r
z(Key not found in the first mapping: {!r}N)r r3 r= ru )r* r r( r r r r3 c s
z ChainMap.popc C s | j d j d S)z'Clear maps[0], leaving maps[1:] intact.r
N)r r; )r* r r r r; j s zChainMap.clear)r r r r` r, r r r r r9 r r rg rP rh rY rR __copy__r propertyr r2 r7 r> r3 r; r r r r r s( c @ s e Z d Z d d Z d d Z d d Z d d Z d d
Z d d Z d
d Z d d Z
d d Z e d d d Z
d S)r c O s | s t d n | ^ } } t | d k rL t d t | n | r_ | d } nF d | k r | j d } d d l } | j d t d d n d } i | _ | d k r | j | n t | r | j | n d S) Nz d? Z" d S)Ar zAA more or less complete user-defined wrapper around list objects.Nc C s g | _ | d k r t | t | j k rF | | j d d d? Z# d@ dA Z$ dB dC Z% dD dE Z& dF dG Z' dH dI Z( dJ dK Z) dL dM Z* dN dO Z+ dP dQ Z, dR dS Z- dT dU Z. dV dW Z/ d0 dX dY Z0 dZ d[ Z1 d~ d] d^ Z2 d- e j d_ d` Z3 d- e j da db Z4 dc dd Z5 de df Z6 d0 dg dh Z7 d0 d di dj Z8 d0 d dk dl Z9 dm dn do Z: d- e j dp dq Z; d0 dr ds Z< dt du Z= dv dw Z> dx dy Z? dz d{ Z@ d| d} ZA d0 S)r c C sV t | t r | | _ n7 t | t rC | j d d | _ n t | | _ d S)N)rZ r~ r r )r* seqr r r r, s
zUserString.__init__c C s
t | j S)N)r~ r )r* r r r __str__ s zUserString.__str__c C s
t | j S)N)r r )r* r r r rP s zUserString.__repr__c C s
t | j S)N)intr )r* r r r __int__
s zUserString.__int__c C s
t | j S)N)floatr )r* r r r __float__ s zUserString.__float__c C s
t | j S)N)complexr )r* r r r __complex__ s zUserString.__complex__c C s
t | j S)N)hashr )r* r r r __hash__
s zUserString.__hash__c C s, t | t r | j | j k S| j | k S)N)rZ r r )r* stringr r r r[ s zUserString.__eq__c C s, t | t r | j | j k S| j | k S)N)rZ r r )r* r r r r re s zUserString.__ne__c C s, t | t r | j | j k S| j | k S)N)rZ r r )r* r r r r r s zUserString.__lt__c C s, t | t r | j | j k S| j | k S)N)rZ r r )r* r r r r r s zUserString.__le__c C s, t | t r | j | j k S| j | k S)N)rZ r r )r* r r r r r s zUserString.__gt__c C s, t | t r | j | j k S| j | k S)N)rZ r r )r* r r r r r # s zUserString.__ge__c C s( t | t r | j } n | | j k S)N)rZ r r )r* charr r r r ( s zUserString.__contains__c C s
t | j S)N)r! r )r* r r r r - s zUserString.__len__c C s | j | j | S)N)rM r )r* rz r r r r . s zUserString.__getitem__c C sc t | t r& | j | j | j St | t rI | j | j | S| j | j t | S)N)rZ r rM r r~ )r* r_ r r r r / s
zUserString.__add__c C s= t | t r# | j | | j S| j t | | j S)N)rZ r~ rM r )r* r_ r r r r 5 s zUserString.__radd__c C s | j | j | S)N)rM r )r* rF r r r r 9 s zUserString.__mul__c C s | j | j | S)N)rM r )r* r( r r r r < s zUserString.__mod__c C s | j | j j S)N)rM r
capitalize)r* r r r r @ s zUserString.capitalizec G s | j | j j | | S)N)rM r center)r* widthr( r r r r A s zUserString.centerr
c C s1 t | t r | j } n | j j | | | S)N)rZ r r r )r* substartendr r r r C s zUserString.countNc C sW | rA | r( | j | j j | | S| j | j j | S| j | j j S)N)rM r encode)r* encodingerrorsr r r r G s
zUserString.encodec C s | j j | | | S)N)r endswith)r* suffixr r r r r r M s zUserString.endswith c C s | j | j j | S)N)rM r
expandtabs)r* tabsizer r r r O s zUserString.expandtabsc C s1 t | t r | j } n | j j | | | S)N)rZ r r find)r* r r r r r r r Q s zUserString.findc O s | j j | | S)N)r ru )r* r( r) r r r ru U s zUserString.formatc C s | j j | | | S)N)r rz )r* r r r r r r rz W s zUserString.indexc C s
| j j S)N)r isalpha)r* r r r r Y s zUserString.isalphac C s
| j j S)N)r isalnum)r* r r r r Z s zUserString.isalnumc C s
| j j S)N)r isdecimal)r* r r r r [ s zUserString.isdecimalc C s
| j j S)N)r isdigit)r* r r r r \ s zUserString.isdigitc C s
| j j S)N)r r )r* r r r r ] s zUserString.isidentifierc C s
| j j S)N)r islower)r* r r r r ^ s zUserString.islowerc C s
| j j S)N)r isnumeric)r* r r r r _ s zUserString.isnumericc C s
| j j S)N)r isspace)r* r r r r ` s zUserString.isspacec C s
| j j S)N)r istitle)r* r r r r a s zUserString.istitlec C s
| j j S)N)r isupper)r* r r r r b s zUserString.isupperc C s | j j | S)N)r r )r* r r r r r c s zUserString.joinc G s | j | j j | | S)N)rM r ljust)r* r r( r r r r
d s zUserString.ljustc C s | j | j j S)N)rM r lower)r* r r r r f s zUserString.lowerc C s | j | j j | S)N)rM r lstrip)r* charsr r r r g s zUserString.lstripc C s | j j | S)N)r partition)r* sepr r r r h s zUserString.partitionr c C sU t | t r | j } n t | t r6 | j } n | j | j j | | | S)N)rZ r r rM r )r* oldnewmaxsplitr r r r j s
zUserString.replacec C s1 t | t r | j } n | j j | | | S)N)rZ r r rfind)r* r r r r r r r p s zUserString.rfindc C s | j j | | | S)N)r rindex)r* r r r r r r r t s zUserString.rindexc G s | j | j j | | S)N)rM r rjust)r* r r( r r r r v s zUserString.rjustc C s | j j | S)N)r
rpartition)r* r r r r r x s zUserString.rpartitionc C s | j | j j | S)N)rM r rstrip)r* r
r r r r z s zUserString.rstripc C s | j j | | S)N)r r )r* r r r r r r | s zUserString.splitc C s | j j | | S)N)r rsplit)r* r r r r r r ~ s zUserString.rsplitFc C s | j j | S)N)r
splitlines)r* keependsr r r r s zUserString.splitlinesc C s | j j | | | S)N)r r )r* prefixr r r r r r s zUserString.startswithc C s | j | j j | S)N)rM r strip)r* r
r r r r s zUserString.stripc C s | j | j j S)N)rM r swapcase)r* r r r r s zUserString.swapcasec C s | j | j j S)N)rM r title)r* r r r r s zUserString.titlec G s | j | j j | S)N)rM r translate)r* r( r r r r s zUserString.translatec C s | j | j j S)N)rM r upper)r* r r r r s zUserString.upperc C s | j | j j | S)N)rM r zfill)r* r r r r r! s zUserString.zfillr} r} r} )Br r r r, r rP r r r r r[ re r r r r r r r r r r r r r r rB maxsizer r r r r ru rz r r r r r r r r r r r r
r r r r r r r r r r r r r r r r r r r! r r r r r sz )0__all___collections_abc _collectionsr r operatorr r r
r^ keywordr r sysrB heapqr _weakrefr r% itertoolsr r r r r r reprlibr rg rf r r< r r rt r{ r r ImportErrorr ra r r MutableSequencer Sequencer r r r r s<
^
|kCJ