Python code coverage for Lib/collections/init.py

#	count	content
1	n/a	'''This module implements specialized container datatypes providing
2	n/a	alternatives to Python's general purpose built-in containers, dict,
3	n/a	list, set, and tuple.
4	n/a
5	n/a	* namedtuple factory function for creating tuple subclasses with named fields
6	n/a	* deque list-like container with fast appends and pops on either end
7	n/a	* ChainMap dict-like class for creating a single view of multiple mappings
8	n/a	* Counter dict subclass for counting hashable objects
9	n/a	* OrderedDict dict subclass that remembers the order entries were added
10	n/a	* defaultdict dict subclass that calls a factory function to supply missing values
11	n/a	* UserDict wrapper around dictionary objects for easier dict subclassing
12	n/a	* UserList wrapper around list objects for easier list subclassing
13	n/a	* UserString wrapper around string objects for easier string subclassing
14	n/a
15	n/a	'''
16	n/a
17	n/a	__all__ = ['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList',
18	n/a	'UserString', 'Counter', 'OrderedDict', 'ChainMap']
19	n/a
20	n/a	# For backwards compatibility, continue to make the collections ABCs
21	n/a	# available through the collections module.
22	n/a	from _collections_abc import *
23	n/a	import _collections_abc
24	n/a	__all__ += _collections_abc.__all__
25	n/a
26	n/a	from operator import itemgetter as _itemgetter, eq as _eq
27	n/a	from keyword import iskeyword as _iskeyword
28	n/a	import sys as _sys
29	n/a	import heapq as _heapq
30	n/a	from _weakref import proxy as _proxy
31	n/a	from itertools import repeat as _repeat, chain as _chain, starmap as _starmap
32	n/a	from reprlib import recursive_repr as _recursive_repr
33	n/a
34	n/a	try:
35	n/a	from _collections import deque
36	n/a	except ImportError:
37	n/a	pass
38	n/a	else:
39	n/a	MutableSequence.register(deque)
40	n/a
41	n/a	try:
42	n/a	from _collections import defaultdict
43	n/a	except ImportError:
44	n/a	pass
45	n/a
46	n/a
47	n/a	################################################################################
48	n/a	### OrderedDict
49	n/a	################################################################################
50	n/a
51	n/a	class _OrderedDictKeysView(KeysView):
52	n/a
53	n/a	def __reversed__(self):
54	n/a	yield from reversed(self._mapping)
55	n/a
56	n/a	class _OrderedDictItemsView(ItemsView):
57	n/a
58	n/a	def __reversed__(self):
59	n/a	for key in reversed(self._mapping):
60	n/a	yield (key, self._mapping[key])
61	n/a
62	n/a	class _OrderedDictValuesView(ValuesView):
63	n/a
64	n/a	def __reversed__(self):
65	n/a	for key in reversed(self._mapping):
66	n/a	yield self._mapping[key]
67	n/a
68	n/a	class _Link(object):
69	n/a	__slots__ = 'prev', 'next', 'key', '__weakref__'
70	n/a
71	n/a	class OrderedDict(dict):
72	n/a	'Dictionary that remembers insertion order'
73	n/a	# An inherited dict maps keys to values.
74	n/a	# The inherited dict provides __getitem__, __len__, __contains__, and get.
75	n/a	# The remaining methods are order-aware.
76	n/a	# Big-O running times for all methods are the same as regular dictionaries.
77	n/a
78	n/a	# The internal self.__map dict maps keys to links in a doubly linked list.
79	n/a	# The circular doubly linked list starts and ends with a sentinel element.
80	n/a	# The sentinel element never gets deleted (this simplifies the algorithm).
81	n/a	# The sentinel is in self.__hardroot with a weakref proxy in self.__root.
82	n/a	# The prev links are weakref proxies (to prevent circular references).
83	n/a	# Individual links are kept alive by the hard reference in self.__map.
84	n/a	# Those hard references disappear when a key is deleted from an OrderedDict.
85	n/a
86	n/a	def __init__(args, *kwds):
87	n/a	'''Initialize an ordered dictionary. The signature is the same as
88	n/a	regular dictionaries, but keyword arguments are not recommended because
89	n/a	their insertion order is arbitrary.
90	n/a
91	n/a	'''
92	n/a	if not args:
93	n/a	raise TypeError("descriptor '__init__' of 'OrderedDict' object "
94	n/a	"needs an argument")
95	n/a	self, *args = args
96	n/a	if len(args) > 1:
97	n/a	raise TypeError('expected at most 1 arguments, got %d' % len(args))
98	n/a	try:
99	n/a	self.__root
100	n/a	except AttributeError:
101	n/a	self.__hardroot = _Link()
102	n/a	self.__root = root = _proxy(self.__hardroot)
103	n/a	root.prev = root.next = root
104	n/a	self.__map = {}
105	n/a	self.__update(args, *kwds)
106	n/a
107	n/a	def __setitem__(self, key, value,
108	n/a	dict_setitem=dict.__setitem__, proxy=_proxy, Link=_Link):
109	n/a	'od.__setitem__(i, y) <==> od[i]=y'
110	n/a	# Setting a new item creates a new link at the end of the linked list,
111	n/a	# and the inherited dictionary is updated with the new key/value pair.
112	n/a	if key not in self:
113	n/a	self.__map[key] = link = Link()
114	n/a	root = self.__root
115	n/a	last = root.prev
116	n/a	link.prev, link.next, link.key = last, root, key
117	n/a	last.next = link
118	n/a	root.prev = proxy(link)
119	n/a	dict_setitem(self, key, value)
120	n/a
121	n/a	def __delitem__(self, key, dict_delitem=dict.__delitem__):
122	n/a	'od.__delitem__(y) <==> del od[y]'
123	n/a	# Deleting an existing item uses self.__map to find the link which gets
124	n/a	# removed by updating the links in the predecessor and successor nodes.
125	n/a	dict_delitem(self, key)
126	n/a	link = self.__map.pop(key)
127	n/a	link_prev = link.prev
128	n/a	link_next = link.next
129	n/a	link_prev.next = link_next
130	n/a	link_next.prev = link_prev
131	n/a	link.prev = None
132	n/a	link.next = None
133	n/a
134	n/a	def __iter__(self):
135	n/a	'od.__iter__() <==> iter(od)'
136	n/a	# Traverse the linked list in order.
137	n/a	root = self.__root
138	n/a	curr = root.next
139	n/a	while curr is not root:
140	n/a	yield curr.key
141	n/a	curr = curr.next
142	n/a
143	n/a	def __reversed__(self):
144	n/a	'od.__reversed__() <==> reversed(od)'
145	n/a	# Traverse the linked list in reverse order.
146	n/a	root = self.__root
147	n/a	curr = root.prev
148	n/a	while curr is not root:
149	n/a	yield curr.key
150	n/a	curr = curr.prev
151	n/a
152	n/a	def clear(self):
153	n/a	'od.clear() -> None. Remove all items from od.'
154	n/a	root = self.__root
155	n/a	root.prev = root.next = root
156	n/a	self.__map.clear()
157	n/a	dict.clear(self)
158	n/a
159	n/a	def popitem(self, last=True):
160	n/a	'''Remove and return a (key, value) pair from the dictionary.
161	n/a
162	n/a	Pairs are returned in LIFO order if last is true or FIFO order if false.
163	n/a	'''
164	n/a	if not self:
165	n/a	raise KeyError('dictionary is empty')
166	n/a	root = self.__root
167	n/a	if last:
168	n/a	link = root.prev
169	n/a	link_prev = link.prev
170	n/a	link_prev.next = root
171	n/a	root.prev = link_prev
172	n/a	else:
173	n/a	link = root.next
174	n/a	link_next = link.next
175	n/a	root.next = link_next
176	n/a	link_next.prev = root
177	n/a	key = link.key
178	n/a	del self.__map[key]
179	n/a	value = dict.pop(self, key)
180	n/a	return key, value
181	n/a
182	n/a	def move_to_end(self, key, last=True):
183	n/a	'''Move an existing element to the end (or beginning if last is false).
184	n/a
185	n/a	Raise KeyError if the element does not exist.
186	n/a	'''
187	n/a	link = self.__map[key]
188	n/a	link_prev = link.prev
189	n/a	link_next = link.next
190	n/a	soft_link = link_next.prev
191	n/a	link_prev.next = link_next
192	n/a	link_next.prev = link_prev
193	n/a	root = self.__root
194	n/a	if last:
195	n/a	last = root.prev
196	n/a	link.prev = last
197	n/a	link.next = root
198	n/a	root.prev = soft_link
199	n/a	last.next = link
200	n/a	else:
201	n/a	first = root.next
202	n/a	link.prev = root
203	n/a	link.next = first
204	n/a	first.prev = soft_link
205	n/a	root.next = link
206	n/a
207	n/a	def __sizeof__(self):
208	n/a	sizeof = _sys.getsizeof
209	n/a	n = len(self) + 1 # number of links including root
210	n/a	size = sizeof(self.__dict__) # instance dictionary
211	n/a	size += sizeof(self.__map) * 2 # internal dict and inherited dict
212	n/a	size += sizeof(self.__hardroot) * n # link objects
213	n/a	size += sizeof(self.__root) * n # proxy objects
214	n/a	return size
215	n/a
216	n/a	update = __update = MutableMapping.update
217	n/a
218	n/a	def keys(self):
219	n/a	"D.keys() -> a set-like object providing a view on D's keys"
220	n/a	return _OrderedDictKeysView(self)
221	n/a
222	n/a	def items(self):
223	n/a	"D.items() -> a set-like object providing a view on D's items"
224	n/a	return _OrderedDictItemsView(self)
225	n/a
226	n/a	def values(self):
227	n/a	"D.values() -> an object providing a view on D's values"
228	n/a	return _OrderedDictValuesView(self)
229	n/a
230	n/a	__ne__ = MutableMapping.__ne__
231	n/a
232	n/a	__marker = object()
233	n/a
234	n/a	def pop(self, key, default=__marker):
235	n/a	'''od.pop(k[,d]) -> v, remove specified key and return the corresponding
236	n/a	value. If key is not found, d is returned if given, otherwise KeyError
237	n/a	is raised.
238	n/a
239	n/a	'''
240	n/a	if key in self:
241	n/a	result = self[key]
242	n/a	del self[key]
243	n/a	return result
244	n/a	if default is self.__marker:
245	n/a	raise KeyError(key)
246	n/a	return default
247	n/a
248	n/a	def setdefault(self, key, default=None):
249	n/a	'''Insert key with a value of default if key is not in the dictionary.
250	n/a
251	n/a	Return the value for key if key is in the dictionary, else default.
252	n/a	'''
253	n/a	if key in self:
254	n/a	return self[key]
255	n/a	self[key] = default
256	n/a	return default
257	n/a
258	n/a	@_recursive_repr()
259	n/a	def __repr__(self):
260	n/a	'od.__repr__() <==> repr(od)'
261	n/a	if not self:
262	n/a	return '%s()' % (self.__class__.__name__,)
263	n/a	return '%s(%r)' % (self.__class__.__name__, list(self.items()))
264	n/a
265	n/a	def __reduce__(self):
266	n/a	'Return state information for pickling'
267	n/a	inst_dict = vars(self).copy()
268	n/a	for k in vars(OrderedDict()):
269	n/a	inst_dict.pop(k, None)
270	n/a	return self.__class__, (), inst_dict or None, None, iter(self.items())
271	n/a
272	n/a	def copy(self):
273	n/a	'od.copy() -> a shallow copy of od'
274	n/a	return self.__class__(self)
275	n/a
276	n/a	@classmethod
277	n/a	def fromkeys(cls, iterable, value=None):
278	n/a	'''Create a new ordered dictionary with keys from iterable and values set to value.
279	n/a	'''
280	n/a	self = cls()
281	n/a	for key in iterable:
282	n/a	self[key] = value
283	n/a	return self
284	n/a
285	n/a	def __eq__(self, other):
286	n/a	'''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
287	n/a	while comparison to a regular mapping is order-insensitive.
288	n/a
289	n/a	'''
290	n/a	if isinstance(other, OrderedDict):
291	n/a	return dict.__eq__(self, other) and all(map(_eq, self, other))
292	n/a	return dict.__eq__(self, other)
293	n/a
294	n/a
295	n/a	try:
296	n/a	from _collections import OrderedDict
297	n/a	except ImportError:
298	n/a	# Leave the pure Python version in place.
299	n/a	pass
300	n/a
301	n/a
302	n/a	################################################################################
303	n/a	### namedtuple
304	n/a	################################################################################
305	n/a
306	n/a	_class_template = """\
307	n/a	from builtins import property as _property, tuple as _tuple
308	n/a	from operator import itemgetter as _itemgetter
309	n/a	from collections import OrderedDict
310	n/a
311	n/a	class {typename}(tuple):
312	n/a	'{typename}({arg_list})'
313	n/a
314	n/a	__slots__ = ()
315	n/a
316	n/a	_fields = {field_names!r}
317	n/a
318	n/a	def __new__(_cls, {arg_list}):
319	n/a	'Create new instance of {typename}({arg_list})'
320	n/a	return _tuple.__new__(_cls, ({arg_list}))
321	n/a
322	n/a	@classmethod
323	n/a	def _make(cls, iterable, new=tuple.__new__, len=len):
324	n/a	'Make a new {typename} object from a sequence or iterable'
325	n/a	result = new(cls, iterable)
326	n/a	if len(result) != {num_fields:d}:
327	n/a	raise TypeError('Expected {num_fields:d} arguments, got %d' % len(result))
328	n/a	return result
329	n/a
330	n/a	def _replace(_self, **kwds):
331	n/a	'Return a new {typename} object replacing specified fields with new values'
332	n/a	result = _self._make(map(kwds.pop, {field_names!r}, _self))
333	n/a	if kwds:
334	n/a	raise ValueError('Got unexpected field names: %r' % list(kwds))
335	n/a	return result
336	n/a
337	n/a	def __repr__(self):
338	n/a	'Return a nicely formatted representation string'
339	n/a	return self.__class__.__name__ + '({repr_fmt})' % self
340	n/a
341	n/a	def _asdict(self):
342	n/a	'Return a new OrderedDict which maps field names to their values.'
343	n/a	return OrderedDict(zip(self._fields, self))
344	n/a
345	n/a	def __getnewargs__(self):
346	n/a	'Return self as a plain tuple. Used by copy and pickle.'
347	n/a	return tuple(self)
348	n/a
349	n/a	{field_defs}
350	n/a	"""
351	n/a
352	n/a	_repr_template = '{name}=%r'
353	n/a
354	n/a	_field_template = '''\
355	n/a	{name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
356	n/a	'''
357	n/a
358	n/a	def namedtuple(typename, field_names, *, verbose=False, rename=False, module=None):
359	n/a	"""Returns a new subclass of tuple with named fields.
360	n/a
361	n/a	>>> Point = namedtuple('Point', ['x', 'y'])
362	n/a	>>> Point.__doc__ # docstring for the new class
363	n/a	'Point(x, y)'
364	n/a	>>> p = Point(11, y=22) # instantiate with positional args or keywords
365	n/a	>>> p[0] + p[1] # indexable like a plain tuple
366	n/a	33
367	n/a	>>> x, y = p # unpack like a regular tuple
368	n/a	>>> x, y
369	n/a	(11, 22)
370	n/a	>>> p.x + p.y # fields also accessible by name
371	n/a	33
372	n/a	>>> d = p._asdict() # convert to a dictionary
373	n/a	>>> d['x']
374	n/a	11
375	n/a	>>> Point(**d) # convert from a dictionary
376	n/a	Point(x=11, y=22)
377	n/a	>>> p._replace(x=100) # _replace() is like str.replace() but targets named fields
378	n/a	Point(x=100, y=22)
379	n/a
380	n/a	"""
381	n/a
382	n/a	# Validate the field names. At the user's option, either generate an error
383	n/a	# message or automatically replace the field name with a valid name.
384	n/a	if isinstance(field_names, str):
385	n/a	field_names = field_names.replace(',', ' ').split()
386	n/a	field_names = list(map(str, field_names))
387	n/a	typename = str(typename)
388	n/a	if rename:
389	n/a	seen = set()
390	n/a	for index, name in enumerate(field_names):
391	n/a	if (not name.isidentifier()
392	n/a	or _iskeyword(name)
393	n/a	or name.startswith('_')
394	n/a	or name in seen):
395	n/a	field_names[index] = '_%d' % index
396	n/a	seen.add(name)
397	n/a	for name in [typename] + field_names:
398	n/a	if type(name) is not str:
399	n/a	raise TypeError('Type names and field names must be strings')
400	n/a	if not name.isidentifier():
401	n/a	raise ValueError('Type names and field names must be valid '
402	n/a	'identifiers: %r' % name)
403	n/a	if _iskeyword(name):
404	n/a	raise ValueError('Type names and field names cannot be a '
405	n/a	'keyword: %r' % name)
406	n/a	seen = set()
407	n/a	for name in field_names:
408	n/a	if name.startswith('_') and not rename:
409	n/a	raise ValueError('Field names cannot start with an underscore: '
410	n/a	'%r' % name)
411	n/a	if name in seen:
412	n/a	raise ValueError('Encountered duplicate field name: %r' % name)
413	n/a	seen.add(name)
414	n/a
415	n/a	# Fill-in the class template
416	n/a	class_definition = _class_template.format(
417	n/a	typename = typename,
418	n/a	field_names = tuple(field_names),
419	n/a	num_fields = len(field_names),
420	n/a	arg_list = repr(tuple(field_names)).replace("'", "")[1:-1],
421	n/a	repr_fmt = ', '.join(_repr_template.format(name=name)
422	n/a	for name in field_names),
423	n/a	field_defs = '\n'.join(_field_template.format(index=index, name=name)
424	n/a	for index, name in enumerate(field_names))
425	n/a	)
426	n/a
427	n/a	# Execute the template string in a temporary namespace and support
428	n/a	# tracing utilities by setting a value for frame.f_globals['__name__']
429	n/a	namespace = dict(__name__='namedtuple_%s' % typename)
430	n/a	exec(class_definition, namespace)
431	n/a	result = namespace[typename]
432	n/a	result._source = class_definition
433	n/a	if verbose:
434	n/a	print(result._source)
435	n/a
436	n/a	# For pickling to work, the __module__ variable needs to be set to the frame
437	n/a	# where the named tuple is created. Bypass this step in environments where
438	n/a	# sys._getframe is not defined (Jython for example) or sys._getframe is not
439	n/a	# defined for arguments greater than 0 (IronPython), or where the user has
440	n/a	# specified a particular module.
441	n/a	if module is None:
442	n/a	try:
443	n/a	module = _sys._getframe(1).f_globals.get('__name__', '__main__')
444	n/a	except (AttributeError, ValueError):
445	n/a	pass
446	n/a	if module is not None:
447	n/a	result.__module__ = module
448	n/a
449	n/a	return result
450	n/a
451	n/a
452	n/a	########################################################################
453	n/a	### Counter
454	n/a	########################################################################
455	n/a
456	n/a	def _count_elements(mapping, iterable):
457	n/a	'Tally elements from the iterable.'
458	n/a	mapping_get = mapping.get
459	n/a	for elem in iterable:
460	n/a	mapping[elem] = mapping_get(elem, 0) + 1
461	n/a
462	n/a	try: # Load C helper function if available
463	n/a	from _collections import _count_elements
464	n/a	except ImportError:
465	n/a	pass
466	n/a
467	n/a	class Counter(dict):
468	n/a	'''Dict subclass for counting hashable items. Sometimes called a bag
469	n/a	or multiset. Elements are stored as dictionary keys and their counts
470	n/a	are stored as dictionary values.
471	n/a
472	n/a	>>> c = Counter('abcdeabcdabcaba') # count elements from a string
473	n/a
474	n/a	>>> c.most_common(3) # three most common elements
475	n/a	[('a', 5), ('b', 4), ('c', 3)]
476	n/a	>>> sorted(c) # list all unique elements
477	n/a	['a', 'b', 'c', 'd', 'e']
478	n/a	>>> ''.join(sorted(c.elements())) # list elements with repetitions
479	n/a	'aaaaabbbbcccdde'
480	n/a	>>> sum(c.values()) # total of all counts
481	n/a	15
482	n/a
483	n/a	>>> c['a'] # count of letter 'a'
484	n/a	5
485	n/a	>>> for elem in 'shazam': # update counts from an iterable
486	n/a	... c[elem] += 1 # by adding 1 to each element's count
487	n/a	>>> c['a'] # now there are seven 'a'
488	n/a	7
489	n/a	>>> del c['b'] # remove all 'b'
490	n/a	>>> c['b'] # now there are zero 'b'
491	n/a	0
492	n/a
493	n/a	>>> d = Counter('simsalabim') # make another counter
494	n/a	>>> c.update(d) # add in the second counter
495	n/a	>>> c['a'] # now there are nine 'a'
496	n/a	9
497	n/a
498	n/a	>>> c.clear() # empty the counter
499	n/a	>>> c
500	n/a	Counter()
501	n/a
502	n/a	Note: If a count is set to zero or reduced to zero, it will remain
503	n/a	in the counter until the entry is deleted or the counter is cleared:
504	n/a
505	n/a	>>> c = Counter('aaabbc')
506	n/a	>>> c['b'] -= 2 # reduce the count of 'b' by two
507	n/a	>>> c.most_common() # 'b' is still in, but its count is zero
508	n/a	[('a', 3), ('c', 1), ('b', 0)]
509	n/a
510	n/a	'''
511	n/a	# References:
512	n/a	# http://en.wikipedia.org/wiki/Multiset
513	n/a	# http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
514	n/a	# http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
515	n/a	# http://code.activestate.com/recipes/259174/
516	n/a	# Knuth, TAOCP Vol. II section 4.6.3
517	n/a
518	n/a	def __init__(args, *kwds):
519	n/a	'''Create a new, empty Counter object. And if given, count elements
520	n/a	from an input iterable. Or, initialize the count from another mapping
521	n/a	of elements to their counts.
522	n/a
523	n/a	>>> c = Counter() # a new, empty counter
524	n/a	>>> c = Counter('gallahad') # a new counter from an iterable
525	n/a	>>> c = Counter({'a': 4, 'b': 2}) # a new counter from a mapping
526	n/a	>>> c = Counter(a=4, b=2) # a new counter from keyword args
527	n/a
528	n/a	'''
529	n/a	if not args:
530	n/a	raise TypeError("descriptor '__init__' of 'Counter' object "
531	n/a	"needs an argument")
532	n/a	self, *args = args
533	n/a	if len(args) > 1:
534	n/a	raise TypeError('expected at most 1 arguments, got %d' % len(args))
535	n/a	super(Counter, self).__init__()
536	n/a	self.update(args, *kwds)
537	n/a
538	n/a	def __missing__(self, key):
539	n/a	'The count of elements not in the Counter is zero.'
540	n/a	# Needed so that self[missing_item] does not raise KeyError
541	n/a	return 0
542	n/a
543	n/a	def most_common(self, n=None):
544	n/a	'''List the n most common elements and their counts from the most
545	n/a	common to the least. If n is None, then list all element counts.
546	n/a
547	n/a	>>> Counter('abcdeabcdabcaba').most_common(3)
548	n/a	[('a', 5), ('b', 4), ('c', 3)]
549	n/a
550	n/a	'''
551	n/a	# Emulate Bag.sortedByCount from Smalltalk
552	n/a	if n is None:
553	n/a	return sorted(self.items(), key=_itemgetter(1), reverse=True)
554	n/a	return _heapq.nlargest(n, self.items(), key=_itemgetter(1))
555	n/a
556	n/a	def elements(self):
557	n/a	'''Iterator over elements repeating each as many times as its count.
558	n/a
559	n/a	>>> c = Counter('ABCABC')
560	n/a	>>> sorted(c.elements())
561	n/a	['A', 'A', 'B', 'B', 'C', 'C']
562	n/a
563	n/a	# Knuth's example for prime factors of 1836: 2*2 3*3 17**1
564	n/a	>>> prime_factors = Counter({2: 2, 3: 3, 17: 1})
565	n/a	>>> product = 1
566	n/a	>>> for factor in prime_factors.elements(): # loop over factors
567	n/a	... product *= factor # and multiply them
568	n/a	>>> product
569	n/a	1836
570	n/a
571	n/a	Note, if an element's count has been set to zero or is a negative
572	n/a	number, elements() will ignore it.
573	n/a
574	n/a	'''
575	n/a	# Emulate Bag.do from Smalltalk and Multiset.begin from C++.
576	n/a	return _chain.from_iterable(_starmap(_repeat, self.items()))
577	n/a
578	n/a	# Override dict methods where necessary
579	n/a
580	n/a	@classmethod
581	n/a	def fromkeys(cls, iterable, v=None):
582	n/a	# There is no equivalent method for counters because setting v=1
583	n/a	# means that no element can have a count greater than one.
584	n/a	raise NotImplementedError(
585	n/a	'Counter.fromkeys() is undefined. Use Counter(iterable) instead.')
586	n/a
587	n/a	def update(args, *kwds):
588	n/a	'''Like dict.update() but add counts instead of replacing them.
589	n/a
590	n/a	Source can be an iterable, a dictionary, or another Counter instance.
591	n/a
592	n/a	>>> c = Counter('which')
593	n/a	>>> c.update('witch') # add elements from another iterable
594	n/a	>>> d = Counter('watch')
595	n/a	>>> c.update(d) # add elements from another counter
596	n/a	>>> c['h'] # four 'h' in which, witch, and watch
597	n/a	4
598	n/a
599	n/a	'''
600	n/a	# The regular dict.update() operation makes no sense here because the
601	n/a	# replace behavior results in the some of original untouched counts
602	n/a	# being mixed-in with all of the other counts for a mismash that
603	n/a	# doesn't have a straight-forward interpretation in most counting
604	n/a	# contexts. Instead, we implement straight-addition. Both the inputs
605	n/a	# and outputs are allowed to contain zero and negative counts.
606	n/a
607	n/a	if not args:
608	n/a	raise TypeError("descriptor 'update' of 'Counter' object "
609	n/a	"needs an argument")
610	n/a	self, *args = args
611	n/a	if len(args) > 1:
612	n/a	raise TypeError('expected at most 1 arguments, got %d' % len(args))
613	n/a	iterable = args[0] if args else None
614	n/a	if iterable is not None:
615	n/a	if isinstance(iterable, Mapping):
616	n/a	if self:
617	n/a	self_get = self.get
618	n/a	for elem, count in iterable.items():
619	n/a	self[elem] = count + self_get(elem, 0)
620	n/a	else:
621	n/a	super(Counter, self).update(iterable) # fast path when counter is empty
622	n/a	else:
623	n/a	_count_elements(self, iterable)
624	n/a	if kwds:
625	n/a	self.update(kwds)
626	n/a
627	n/a	def subtract(args, *kwds):
628	n/a	'''Like dict.update() but subtracts counts instead of replacing them.
629	n/a	Counts can be reduced below zero. Both the inputs and outputs are
630	n/a	allowed to contain zero and negative counts.
631	n/a
632	n/a	Source can be an iterable, a dictionary, or another Counter instance.
633	n/a
634	n/a	>>> c = Counter('which')
635	n/a	>>> c.subtract('witch') # subtract elements from another iterable
636	n/a	>>> c.subtract(Counter('watch')) # subtract elements from another counter
637	n/a	>>> c['h'] # 2 in which, minus 1 in witch, minus 1 in watch
638	n/a	0
639	n/a	>>> c['w'] # 1 in which, minus 1 in witch, minus 1 in watch
640	n/a	-1
641	n/a
642	n/a	'''
643	n/a	if not args:
644	n/a	raise TypeError("descriptor 'subtract' of 'Counter' object "
645	n/a	"needs an argument")
646	n/a	self, *args = args
647	n/a	if len(args) > 1:
648	n/a	raise TypeError('expected at most 1 arguments, got %d' % len(args))
649	n/a	iterable = args[0] if args else None
650	n/a	if iterable is not None:
651	n/a	self_get = self.get
652	n/a	if isinstance(iterable, Mapping):
653	n/a	for elem, count in iterable.items():
654	n/a	self[elem] = self_get(elem, 0) - count
655	n/a	else:
656	n/a	for elem in iterable:
657	n/a	self[elem] = self_get(elem, 0) - 1
658	n/a	if kwds:
659	n/a	self.subtract(kwds)
660	n/a
661	n/a	def copy(self):
662	n/a	'Return a shallow copy.'
663	n/a	return self.__class__(self)
664	n/a
665	n/a	def __reduce__(self):
666	n/a	return self.__class__, (dict(self),)
667	n/a
668	n/a	def __delitem__(self, elem):
669	n/a	'Like dict.__delitem__() but does not raise KeyError for missing values.'
670	n/a	if elem in self:
671	n/a	super().__delitem__(elem)
672	n/a
673	n/a	def __repr__(self):
674	n/a	if not self:
675	n/a	return '%s()' % self.__class__.__name__
676	n/a	try:
677	n/a	items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
678	n/a	return '%s({%s})' % (self.__class__.__name__, items)
679	n/a	except TypeError:
680	n/a	# handle case where values are not orderable
681	n/a	return '{0}({1!r})'.format(self.__class__.__name__, dict(self))
682	n/a
683	n/a	# Multiset-style mathematical operations discussed in:
684	n/a	# Knuth TAOCP Volume II section 4.6.3 exercise 19
685	n/a	# and at http://en.wikipedia.org/wiki/Multiset
686	n/a	#
687	n/a	# Outputs guaranteed to only include positive counts.
688	n/a	#
689	n/a	# To strip negative and zero counts, add-in an empty counter:
690	n/a	# c += Counter()
691	n/a
692	n/a	def __add__(self, other):
693	n/a	'''Add counts from two counters.
694	n/a
695	n/a	>>> Counter('abbb') + Counter('bcc')
696	n/a	Counter({'b': 4, 'c': 2, 'a': 1})
697	n/a
698	n/a	'''
699	n/a	if not isinstance(other, Counter):
700	n/a	return NotImplemented
701	n/a	result = Counter()
702	n/a	for elem, count in self.items():
703	n/a	newcount = count + other[elem]
704	n/a	if newcount > 0:
705	n/a	result[elem] = newcount
706	n/a	for elem, count in other.items():
707	n/a	if elem not in self and count > 0:
708	n/a	result[elem] = count
709	n/a	return result
710	n/a
711	n/a	def __sub__(self, other):
712	n/a	''' Subtract count, but keep only results with positive counts.
713	n/a
714	n/a	>>> Counter('abbbc') - Counter('bccd')
715	n/a	Counter({'b': 2, 'a': 1})
716	n/a
717	n/a	'''
718	n/a	if not isinstance(other, Counter):
719	n/a	return NotImplemented
720	n/a	result = Counter()
721	n/a	for elem, count in self.items():
722	n/a	newcount = count - other[elem]
723	n/a	if newcount > 0:
724	n/a	result[elem] = newcount
725	n/a	for elem, count in other.items():
726	n/a	if elem not in self and count < 0:
727	n/a	result[elem] = 0 - count
728	n/a	return result
729	n/a
730	n/a	def __or__(self, other):
731	n/a	'''Union is the maximum of value in either of the input counters.
732	n/a
733	n/a	>>> Counter('abbb') \| Counter('bcc')
734	n/a	Counter({'b': 3, 'c': 2, 'a': 1})
735	n/a
736	n/a	'''
737	n/a	if not isinstance(other, Counter):
738	n/a	return NotImplemented
739	n/a	result = Counter()
740	n/a	for elem, count in self.items():
741	n/a	other_count = other[elem]
742	n/a	newcount = other_count if count < other_count else count
743	n/a	if newcount > 0:
744	n/a	result[elem] = newcount
745	n/a	for elem, count in other.items():
746	n/a	if elem not in self and count > 0:
747	n/a	result[elem] = count
748	n/a	return result
749	n/a
750	n/a	def __and__(self, other):
751	n/a	''' Intersection is the minimum of corresponding counts.
752	n/a
753	n/a	>>> Counter('abbb') & Counter('bcc')
754	n/a	Counter({'b': 1})
755	n/a
756	n/a	'''
757	n/a	if not isinstance(other, Counter):
758	n/a	return NotImplemented
759	n/a	result = Counter()
760	n/a	for elem, count in self.items():
761	n/a	other_count = other[elem]
762	n/a	newcount = count if count < other_count else other_count
763	n/a	if newcount > 0:
764	n/a	result[elem] = newcount
765	n/a	return result
766	n/a
767	n/a	def __pos__(self):
768	n/a	'Adds an empty counter, effectively stripping negative and zero counts'
769	n/a	result = Counter()
770	n/a	for elem, count in self.items():
771	n/a	if count > 0:
772	n/a	result[elem] = count
773	n/a	return result
774	n/a
775	n/a	def __neg__(self):
776	n/a	'''Subtracts from an empty counter. Strips positive and zero counts,
777	n/a	and flips the sign on negative counts.
778	n/a
779	n/a	'''
780	n/a	result = Counter()
781	n/a	for elem, count in self.items():
782	n/a	if count < 0:
783	n/a	result[elem] = 0 - count
784	n/a	return result
785	n/a
786	n/a	def _keep_positive(self):
787	n/a	'''Internal method to strip elements with a negative or zero count'''
788	n/a	nonpositive = [elem for elem, count in self.items() if not count > 0]
789	n/a	for elem in nonpositive:
790	n/a	del self[elem]
791	n/a	return self
792	n/a
793	n/a	def __iadd__(self, other):
794	n/a	'''Inplace add from another counter, keeping only positive counts.
795	n/a
796	n/a	>>> c = Counter('abbb')
797	n/a	>>> c += Counter('bcc')
798	n/a	>>> c
799	n/a	Counter({'b': 4, 'c': 2, 'a': 1})
800	n/a
801	n/a	'''
802	n/a	for elem, count in other.items():
803	n/a	self[elem] += count
804	n/a	return self._keep_positive()
805	n/a
806	n/a	def __isub__(self, other):
807	n/a	'''Inplace subtract counter, but keep only results with positive counts.
808	n/a
809	n/a	>>> c = Counter('abbbc')
810	n/a	>>> c -= Counter('bccd')
811	n/a	>>> c
812	n/a	Counter({'b': 2, 'a': 1})
813	n/a
814	n/a	'''
815	n/a	for elem, count in other.items():
816	n/a	self[elem] -= count
817	n/a	return self._keep_positive()
818	n/a
819	n/a	def __ior__(self, other):
820	n/a	'''Inplace union is the maximum of value from either counter.
821	n/a
822	n/a	>>> c = Counter('abbb')
823	n/a	>>> c \|= Counter('bcc')
824	n/a	>>> c
825	n/a	Counter({'b': 3, 'c': 2, 'a': 1})
826	n/a
827	n/a	'''
828	n/a	for elem, other_count in other.items():
829	n/a	count = self[elem]
830	n/a	if other_count > count:
831	n/a	self[elem] = other_count
832	n/a	return self._keep_positive()
833	n/a
834	n/a	def __iand__(self, other):
835	n/a	'''Inplace intersection is the minimum of corresponding counts.
836	n/a
837	n/a	>>> c = Counter('abbb')
838	n/a	>>> c &= Counter('bcc')
839	n/a	>>> c
840	n/a	Counter({'b': 1})
841	n/a
842	n/a	'''
843	n/a	for elem, count in self.items():
844	n/a	other_count = other[elem]
845	n/a	if other_count < count:
846	n/a	self[elem] = other_count
847	n/a	return self._keep_positive()
848	n/a
849	n/a
850	n/a	########################################################################
851	n/a	### ChainMap
852	n/a	########################################################################
853	n/a
854	n/a	class ChainMap(MutableMapping):
855	n/a	''' A ChainMap groups multiple dicts (or other mappings) together
856	n/a	to create a single, updateable view.
857	n/a
858	n/a	The underlying mappings are stored in a list. That list is public and can
859	n/a	be accessed or updated using the maps attribute. There is no other
860	n/a	state.
861	n/a
862	n/a	Lookups search the underlying mappings successively until a key is found.
863	n/a	In contrast, writes, updates, and deletions only operate on the first
864	n/a	mapping.
865	n/a
866	n/a	'''
867	n/a
868	n/a	def __init__(self, *maps):
869	n/a	'''Initialize a ChainMap by setting maps to the given mappings.
870	n/a	If no mappings are provided, a single empty dictionary is used.
871	n/a
872	n/a	'''
873	n/a	self.maps = list(maps) or [{}] # always at least one map
874	n/a
875	n/a	def __missing__(self, key):
876	n/a	raise KeyError(key)
877	n/a
878	n/a	def __getitem__(self, key):
879	n/a	for mapping in self.maps:
880	n/a	try:
881	n/a	return mapping[key] # can't use 'key in mapping' with defaultdict
882	n/a	except KeyError:
883	n/a	pass
884	n/a	return self.__missing__(key) # support subclasses that define __missing__
885	n/a
886	n/a	def get(self, key, default=None):
887	n/a	return self[key] if key in self else default
888	n/a
889	n/a	def __len__(self):
890	n/a	return len(set().union(*self.maps)) # reuses stored hash values if possible
891	n/a
892	n/a	def __iter__(self):
893	n/a	return iter(set().union(*self.maps))
894	n/a
895	n/a	def __contains__(self, key):
896	n/a	return any(key in m for m in self.maps)
897	n/a
898	n/a	def __bool__(self):
899	n/a	return any(self.maps)
900	n/a
901	n/a	@_recursive_repr()
902	n/a	def __repr__(self):
903	n/a	return '{0.__class__.__name__}({1})'.format(
904	n/a	self, ', '.join(map(repr, self.maps)))
905	n/a
906	n/a	@classmethod
907	n/a	def fromkeys(cls, iterable, *args):
908	n/a	'Create a ChainMap with a single dict created from the iterable.'
909	n/a	return cls(dict.fromkeys(iterable, *args))
910	n/a
911	n/a	def copy(self):
912	n/a	'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]'
913	n/a	return self.__class__(self.maps[0].copy(), *self.maps[1:])
914	n/a
915	n/a	__copy__ = copy
916	n/a
917	n/a	def new_child(self, m=None): # like Django's Context.push()
918	n/a	'''New ChainMap with a new map followed by all previous maps.
919	n/a	If no map is provided, an empty dict is used.
920	n/a	'''
921	n/a	if m is None:
922	n/a	m = {}
923	n/a	return self.__class__(m, *self.maps)
924	n/a
925	n/a	@property
926	n/a	def parents(self): # like Django's Context.pop()
927	n/a	'New ChainMap from maps[1:].'
928	n/a	return self.__class__(*self.maps[1:])
929	n/a
930	n/a	def __setitem__(self, key, value):
931	n/a	self.maps[0][key] = value
932	n/a
933	n/a	def __delitem__(self, key):
934	n/a	try:
935	n/a	del self.maps[0][key]
936	n/a	except KeyError:
937	n/a	raise KeyError('Key not found in the first mapping: {!r}'.format(key))
938	n/a
939	n/a	def popitem(self):
940	n/a	'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.'
941	n/a	try:
942	n/a	return self.maps[0].popitem()
943	n/a	except KeyError:
944	n/a	raise KeyError('No keys found in the first mapping.')
945	n/a
946	n/a	def pop(self, key, *args):
947	n/a	'Remove key from maps[0] and return its value. Raise KeyError if key not in maps[0].'
948	n/a	try:
949	n/a	return self.maps[0].pop(key, *args)
950	n/a	except KeyError:
951	n/a	raise KeyError('Key not found in the first mapping: {!r}'.format(key))
952	n/a
953	n/a	def clear(self):
954	n/a	'Clear maps[0], leaving maps[1:] intact.'
955	n/a	self.maps[0].clear()
956	n/a
957	n/a
958	n/a	################################################################################
959	n/a	### UserDict
960	n/a	################################################################################
961	n/a
962	n/a	class UserDict(MutableMapping):
963	n/a
964	n/a	# Start by filling-out the abstract methods
965	n/a	def __init__(args, *kwargs):
966	n/a	if not args:
967	n/a	raise TypeError("descriptor '__init__' of 'UserDict' object "
968	n/a	"needs an argument")
969	n/a	self, *args = args
970	n/a	if len(args) > 1:
971	n/a	raise TypeError('expected at most 1 arguments, got %d' % len(args))
972	n/a	if args:
973	n/a	dict = args[0]
974	n/a	elif 'dict' in kwargs:
975	n/a	dict = kwargs.pop('dict')
976	n/a	import warnings
977	n/a	warnings.warn("Passing 'dict' as keyword argument is deprecated",
978	n/a	DeprecationWarning, stacklevel=2)
979	n/a	else:
980	n/a	dict = None
981	n/a	self.data = {}
982	n/a	if dict is not None:
983	n/a	self.update(dict)
984	n/a	if len(kwargs):
985	n/a	self.update(kwargs)
986	n/a	def __len__(self): return len(self.data)
987	n/a	def __getitem__(self, key):
988	n/a	if key in self.data:
989	n/a	return self.data[key]
990	n/a	if hasattr(self.__class__, "__missing__"):
991	n/a	return self.__class__.__missing__(self, key)
992	n/a	raise KeyError(key)
993	n/a	def __setitem__(self, key, item): self.data[key] = item
994	n/a	def __delitem__(self, key): del self.data[key]
995	n/a	def __iter__(self):
996	n/a	return iter(self.data)
997	n/a
998	n/a	# Modify __contains__ to work correctly when __missing__ is present
999	n/a	def __contains__(self, key):
1000	n/a	return key in self.data
1001	n/a
1002	n/a	# Now, add the methods in dicts but not in MutableMapping
1003	n/a	def __repr__(self): return repr(self.data)
1004	n/a	def copy(self):
1005	n/a	if self.__class__ is UserDict:
1006	n/a	return UserDict(self.data.copy())
1007	n/a	import copy
1008	n/a	data = self.data
1009	n/a	try:
1010	n/a	self.data = {}
1011	n/a	c = copy.copy(self)
1012	n/a	finally:
1013	n/a	self.data = data
1014	n/a	c.update(self)
1015	n/a	return c
1016	n/a	@classmethod
1017	n/a	def fromkeys(cls, iterable, value=None):
1018	n/a	d = cls()
1019	n/a	for key in iterable:
1020	n/a	d[key] = value
1021	n/a	return d
1022	n/a
1023	n/a
1024	n/a
1025	n/a	################################################################################
1026	n/a	### UserList
1027	n/a	################################################################################
1028	n/a
1029	n/a	class UserList(MutableSequence):
1030	n/a	"""A more or less complete user-defined wrapper around list objects."""
1031	n/a	def __init__(self, initlist=None):
1032	n/a	self.data = []
1033	n/a	if initlist is not None:
1034	n/a	# XXX should this accept an arbitrary sequence?
1035	n/a	if type(initlist) == type(self.data):
1036	n/a	self.data[:] = initlist
1037	n/a	elif isinstance(initlist, UserList):
1038	n/a	self.data[:] = initlist.data[:]
1039	n/a	else:
1040	n/a	self.data = list(initlist)
1041	n/a	def __repr__(self): return repr(self.data)
1042	n/a	def __lt__(self, other): return self.data < self.__cast(other)
1043	n/a	def __le__(self, other): return self.data <= self.__cast(other)
1044	n/a	def __eq__(self, other): return self.data == self.__cast(other)
1045	n/a	def __gt__(self, other): return self.data > self.__cast(other)
1046	n/a	def __ge__(self, other): return self.data >= self.__cast(other)
1047	n/a	def __cast(self, other):
1048	n/a	return other.data if isinstance(other, UserList) else other
1049	n/a	def __contains__(self, item): return item in self.data
1050	n/a	def __len__(self): return len(self.data)
1051	n/a	def __getitem__(self, i): return self.data[i]
1052	n/a	def __setitem__(self, i, item): self.data[i] = item
1053	n/a	def __delitem__(self, i): del self.data[i]
1054	n/a	def __add__(self, other):
1055	n/a	if isinstance(other, UserList):
1056	n/a	return self.__class__(self.data + other.data)
1057	n/a	elif isinstance(other, type(self.data)):
1058	n/a	return self.__class__(self.data + other)
1059	n/a	return self.__class__(self.data + list(other))
1060	n/a	def __radd__(self, other):
1061	n/a	if isinstance(other, UserList):
1062	n/a	return self.__class__(other.data + self.data)
1063	n/a	elif isinstance(other, type(self.data)):
1064	n/a	return self.__class__(other + self.data)
1065	n/a	return self.__class__(list(other) + self.data)
1066	n/a	def __iadd__(self, other):
1067	n/a	if isinstance(other, UserList):
1068	n/a	self.data += other.data
1069	n/a	elif isinstance(other, type(self.data)):
1070	n/a	self.data += other
1071	n/a	else:
1072	n/a	self.data += list(other)
1073	n/a	return self
1074	n/a	def __mul__(self, n):
1075	n/a	return self.__class__(self.data*n)
1076	n/a	__rmul__ = __mul__
1077	n/a	def __imul__(self, n):
1078	n/a	self.data *= n
1079	n/a	return self
1080	n/a	def append(self, item): self.data.append(item)
1081	n/a	def insert(self, i, item): self.data.insert(i, item)
1082	n/a	def pop(self, i=-1): return self.data.pop(i)
1083	n/a	def remove(self, item): self.data.remove(item)
1084	n/a	def clear(self): self.data.clear()
1085	n/a	def copy(self): return self.__class__(self)
1086	n/a	def count(self, item): return self.data.count(item)
1087	n/a	def index(self, item, args): return self.data.index(item, args)
1088	n/a	def reverse(self): self.data.reverse()
1089	n/a	def sort(self, args, kwds): self.data.sort(args, **kwds)
1090	n/a	def extend(self, other):
1091	n/a	if isinstance(other, UserList):
1092	n/a	self.data.extend(other.data)
1093	n/a	else:
1094	n/a	self.data.extend(other)
1095	n/a
1096	n/a
1097	n/a
1098	n/a	################################################################################
1099	n/a	### UserString
1100	n/a	################################################################################
1101	n/a
1102	n/a	class UserString(Sequence):
1103	n/a	def __init__(self, seq):
1104	n/a	if isinstance(seq, str):
1105	n/a	self.data = seq
1106	n/a	elif isinstance(seq, UserString):
1107	n/a	self.data = seq.data[:]
1108	n/a	else:
1109	n/a	self.data = str(seq)
1110	n/a	def __str__(self): return str(self.data)
1111	n/a	def __repr__(self): return repr(self.data)
1112	n/a	def __int__(self): return int(self.data)
1113	n/a	def __float__(self): return float(self.data)
1114	n/a	def __complex__(self): return complex(self.data)
1115	n/a	def __hash__(self): return hash(self.data)
1116	n/a	def __getnewargs__(self):
1117	n/a	return (self.data[:],)
1118	n/a
1119	n/a	def __eq__(self, string):
1120	n/a	if isinstance(string, UserString):
1121	n/a	return self.data == string.data
1122	n/a	return self.data == string
1123	n/a	def __lt__(self, string):
1124	n/a	if isinstance(string, UserString):
1125	n/a	return self.data < string.data
1126	n/a	return self.data < string
1127	n/a	def __le__(self, string):
1128	n/a	if isinstance(string, UserString):
1129	n/a	return self.data <= string.data
1130	n/a	return self.data <= string
1131	n/a	def __gt__(self, string):
1132	n/a	if isinstance(string, UserString):
1133	n/a	return self.data > string.data
1134	n/a	return self.data > string
1135	n/a	def __ge__(self, string):
1136	n/a	if isinstance(string, UserString):
1137	n/a	return self.data >= string.data
1138	n/a	return self.data >= string
1139	n/a
1140	n/a	def __contains__(self, char):
1141	n/a	if isinstance(char, UserString):
1142	n/a	char = char.data
1143	n/a	return char in self.data
1144	n/a
1145	n/a	def __len__(self): return len(self.data)
1146	n/a	def __getitem__(self, index): return self.__class__(self.data[index])
1147	n/a	def __add__(self, other):
1148	n/a	if isinstance(other, UserString):
1149	n/a	return self.__class__(self.data + other.data)
1150	n/a	elif isinstance(other, str):
1151	n/a	return self.__class__(self.data + other)
1152	n/a	return self.__class__(self.data + str(other))
1153	n/a	def __radd__(self, other):
1154	n/a	if isinstance(other, str):
1155	n/a	return self.__class__(other + self.data)
1156	n/a	return self.__class__(str(other) + self.data)
1157	n/a	def __mul__(self, n):
1158	n/a	return self.__class__(self.data*n)
1159	n/a	__rmul__ = __mul__
1160	n/a	def __mod__(self, args):
1161	n/a	return self.__class__(self.data % args)
1162	n/a	def __rmod__(self, format):
1163	n/a	return self.__class__(format % args)
1164	n/a
1165	n/a	# the following methods are defined in alphabetical order:
1166	n/a	def capitalize(self): return self.__class__(self.data.capitalize())
1167	n/a	def casefold(self):
1168	n/a	return self.__class__(self.data.casefold())
1169	n/a	def center(self, width, *args):
1170	n/a	return self.__class__(self.data.center(width, *args))
1171	n/a	def count(self, sub, start=0, end=_sys.maxsize):
1172	n/a	if isinstance(sub, UserString):
1173	n/a	sub = sub.data
1174	n/a	return self.data.count(sub, start, end)
1175	n/a	def encode(self, encoding=None, errors=None): # XXX improve this?
1176	n/a	if encoding:
1177	n/a	if errors:
1178	n/a	return self.__class__(self.data.encode(encoding, errors))
1179	n/a	return self.__class__(self.data.encode(encoding))
1180	n/a	return self.__class__(self.data.encode())
1181	n/a	def endswith(self, suffix, start=0, end=_sys.maxsize):
1182	n/a	return self.data.endswith(suffix, start, end)
1183	n/a	def expandtabs(self, tabsize=8):
1184	n/a	return self.__class__(self.data.expandtabs(tabsize))
1185	n/a	def find(self, sub, start=0, end=_sys.maxsize):
1186	n/a	if isinstance(sub, UserString):
1187	n/a	sub = sub.data
1188	n/a	return self.data.find(sub, start, end)
1189	n/a	def format(self, args, *kwds):
1190	n/a	return self.data.format(args, *kwds)
1191	n/a	def format_map(self, mapping):
1192	n/a	return self.data.format_map(mapping)
1193	n/a	def index(self, sub, start=0, end=_sys.maxsize):
1194	n/a	return self.data.index(sub, start, end)
1195	n/a	def isalpha(self): return self.data.isalpha()
1196	n/a	def isalnum(self): return self.data.isalnum()
1197	n/a	def isdecimal(self): return self.data.isdecimal()
1198	n/a	def isdigit(self): return self.data.isdigit()
1199	n/a	def isidentifier(self): return self.data.isidentifier()
1200	n/a	def islower(self): return self.data.islower()
1201	n/a	def isnumeric(self): return self.data.isnumeric()
1202	n/a	def isprintable(self): return self.data.isprintable()
1203	n/a	def isspace(self): return self.data.isspace()
1204	n/a	def istitle(self): return self.data.istitle()
1205	n/a	def isupper(self): return self.data.isupper()
1206	n/a	def join(self, seq): return self.data.join(seq)
1207	n/a	def ljust(self, width, *args):
1208	n/a	return self.__class__(self.data.ljust(width, *args))
1209	n/a	def lower(self): return self.__class__(self.data.lower())
1210	n/a	def lstrip(self, chars=None): return self.__class__(self.data.lstrip(chars))
1211	n/a	maketrans = str.maketrans
1212	n/a	def partition(self, sep):
1213	n/a	return self.data.partition(sep)
1214	n/a	def replace(self, old, new, maxsplit=-1):
1215	n/a	if isinstance(old, UserString):
1216	n/a	old = old.data
1217	n/a	if isinstance(new, UserString):
1218	n/a	new = new.data
1219	n/a	return self.__class__(self.data.replace(old, new, maxsplit))
1220	n/a	def rfind(self, sub, start=0, end=_sys.maxsize):
1221	n/a	if isinstance(sub, UserString):
1222	n/a	sub = sub.data
1223	n/a	return self.data.rfind(sub, start, end)
1224	n/a	def rindex(self, sub, start=0, end=_sys.maxsize):
1225	n/a	return self.data.rindex(sub, start, end)
1226	n/a	def rjust(self, width, *args):
1227	n/a	return self.__class__(self.data.rjust(width, *args))
1228	n/a	def rpartition(self, sep):
1229	n/a	return self.data.rpartition(sep)
1230	n/a	def rstrip(self, chars=None):
1231	n/a	return self.__class__(self.data.rstrip(chars))
1232	n/a	def split(self, sep=None, maxsplit=-1):
1233	n/a	return self.data.split(sep, maxsplit)
1234	n/a	def rsplit(self, sep=None, maxsplit=-1):
1235	n/a	return self.data.rsplit(sep, maxsplit)
1236	n/a	def splitlines(self, keepends=False): return self.data.splitlines(keepends)
1237	n/a	def startswith(self, prefix, start=0, end=_sys.maxsize):
1238	n/a	return self.data.startswith(prefix, start, end)
1239	n/a	def strip(self, chars=None): return self.__class__(self.data.strip(chars))
1240	n/a	def swapcase(self): return self.__class__(self.data.swapcase())
1241	n/a	def title(self): return self.__class__(self.data.title())
1242	n/a	def translate(self, *args):
1243	n/a	return self.__class__(self.data.translate(*args))
1244	n/a	def upper(self): return self.__class__(self.data.upper())
1245	n/a	def zfill(self, width): return self.__class__(self.data.zfill(width))

Python code coverage for Lib/collections/__init__.py

Python code coverage for Lib/collections/init.py