--- /dev/null
+__all__ = ['deque', 'defaultdict', 'namedtuple', 'UserDict', 'UserList',
+ 'UserString', 'Counter', 'OrderedDict', 'ChainMap']
+
+# For backwards compatibility, continue to make the collections ABCs
+# available through the collections module.
+from _collections_abc import *
+import _collections_abc
+__all__ += _collections_abc.__all__
+
+from _collections import deque, defaultdict
+from operator import itemgetter as _itemgetter, eq as _eq
+from keyword import iskeyword as _iskeyword
+import sys as _sys
+import heapq as _heapq
+from _weakref import proxy as _proxy
+from itertools import repeat as _repeat, chain as _chain, starmap as _starmap
+from reprlib import recursive_repr as _recursive_repr
+
+################################################################################
+### OrderedDict
+################################################################################
+
+class _Link(object):
+ __slots__ = 'prev', 'next', 'key', '__weakref__'
+
+class OrderedDict(dict):
+ 'Dictionary that remembers insertion order'
+ # An inherited dict maps keys to values.
+ # The inherited dict provides __getitem__, __len__, __contains__, and get.
+ # The remaining methods are order-aware.
+ # Big-O running times for all methods are the same as regular dictionaries.
+
+ # The internal self.__map dict maps keys to links in a doubly linked list.
+ # The circular doubly linked list starts and ends with a sentinel element.
+ # The sentinel element never gets deleted (this simplifies the algorithm).
+ # The sentinel is in self.__hardroot with a weakref proxy in self.__root.
+ # The prev links are weakref proxies (to prevent circular references).
+ # Individual links are kept alive by the hard reference in self.__map.
+ # Those hard references disappear when a key is deleted from an OrderedDict.
+
+ def __init__(self, *args, **kwds):
+ '''Initialize an ordered dictionary. The signature is the same as
+ regular dictionaries, but keyword arguments are not recommended because
+ their insertion order is arbitrary.
+
+ '''
+ if len(args) > 1:
+ raise TypeError('expected at most 1 arguments, got %d' % len(args))
+ try:
+ self.__root
+ except AttributeError:
+ self.__hardroot = _Link()
+ self.__root = root = _proxy(self.__hardroot)
+ root.prev = root.next = root
+ self.__map = {}
+ self.__update(*args, **kwds)
+
+ def __setitem__(self, key, value,
+ dict_setitem=dict.__setitem__, proxy=_proxy, Link=_Link):
+ 'od.__setitem__(i, y) <==> od[i]=y'
+ # Setting a new item creates a new link at the end of the linked list,
+ # and the inherited dictionary is updated with the new key/value pair.
+ if key not in self:
+ self.__map[key] = link = Link()
+ root = self.__root
+ last = root.prev
+ link.prev, link.next, link.key = last, root, key
+ last.next = link
+ root.prev = proxy(link)
+ dict_setitem(self, key, value)
+
+ def __delitem__(self, key, dict_delitem=dict.__delitem__):
+ 'od.__delitem__(y) <==> del od[y]'
+ # Deleting an existing item uses self.__map to find the link which gets
+ # removed by updating the links in the predecessor and successor nodes.
+ dict_delitem(self, key)
+ link = self.__map.pop(key)
+ link_prev = link.prev
+ link_next = link.next
+ link_prev.next = link_next
+ link_next.prev = link_prev
+
+ def __iter__(self):
+ 'od.__iter__() <==> iter(od)'
+ # Traverse the linked list in order.
+ root = self.__root
+ curr = root.next
+ while curr is not root:
+ yield curr.key
+ curr = curr.next
+
+ def __reversed__(self):
+ 'od.__reversed__() <==> reversed(od)'
+ # Traverse the linked list in reverse order.
+ root = self.__root
+ curr = root.prev
+ while curr is not root:
+ yield curr.key
+ curr = curr.prev
+
+ def clear(self):
+ 'od.clear() -> None. Remove all items from od.'
+ root = self.__root
+ root.prev = root.next = root
+ self.__map.clear()
+ dict.clear(self)
+
+ def popitem(self, last=True):
+ '''od.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.
+
+ '''
+ if not self:
+ raise KeyError('dictionary is empty')
+ root = self.__root
+ if last:
+ link = root.prev
+ link_prev = link.prev
+ link_prev.next = root
+ root.prev = link_prev
+ else:
+ link = root.next
+ link_next = link.next
+ root.next = link_next
+ link_next.prev = root
+ key = link.key
+ del self.__map[key]
+ value = dict.pop(self, key)
+ return key, value
+
+ def move_to_end(self, key, last=True):
+ '''Move 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).
+
+ '''
+ link = self.__map[key]
+ link_prev = link.prev
+ link_next = link.next
+ link_prev.next = link_next
+ link_next.prev = link_prev
+ root = self.__root
+ if last:
+ last = root.prev
+ link.prev = last
+ link.next = root
+ last.next = root.prev = link
+ else:
+ first = root.next
+ link.prev = root
+ link.next = first
+ root.next = first.prev = link
+
+ def __sizeof__(self):
+ sizeof = _sys.getsizeof
+ n = len(self) + 1 # number of links including root
+ size = sizeof(self.__dict__) # instance dictionary
+ size += sizeof(self.__map) * 2 # internal dict and inherited dict
+ size += sizeof(self.__hardroot) * n # link objects
+ size += sizeof(self.__root) * n # proxy objects
+ return size
+
+ update = __update = MutableMapping.update
+ keys = MutableMapping.keys
+ values = MutableMapping.values
+ items = MutableMapping.items
+ __ne__ = MutableMapping.__ne__
+
+ __marker = object()
+
+ def pop(self, key, default=__marker):
+ '''od.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.
+
+ '''
+ if key in self:
+ result = self[key]
+ del self[key]
+ return result
+ if default is self.__marker:
+ raise KeyError(key)
+ return default
+
+ def setdefault(self, key, default=None):
+ 'od.setdefault(k[,d]) -> od.get(k,d), also set od[k]=d if k not in od'
+ if key in self:
+ return self[key]
+ self[key] = default
+ return default
+
+ @_recursive_repr()
+ def __repr__(self):
+ 'od.__repr__() <==> repr(od)'
+ if not self:
+ return '%s()' % (self.__class__.__name__,)
+ return '%s(%r)' % (self.__class__.__name__, list(self.items()))
+
+ def __reduce__(self):
+ 'Return state information for pickling'
+ inst_dict = vars(self).copy()
+ for k in vars(OrderedDict()):
+ inst_dict.pop(k, None)
+ return self.__class__, (), inst_dict or None, None, iter(self.items())
+
+ def copy(self):
+ 'od.copy() -> a shallow copy of od'
+ return self.__class__(self)
+
+ @classmethod
+ def fromkeys(cls, iterable, value=None):
+ '''OD.fromkeys(S[, v]) -> New ordered dictionary with keys from S.
+ If not specified, the value defaults to None.
+
+ '''
+ self = cls()
+ for key in iterable:
+ self[key] = value
+ return self
+
+ def __eq__(self, other):
+ '''od.__eq__(y) <==> od==y. Comparison to another OD is order-sensitive
+ while comparison to a regular mapping is order-insensitive.
+
+ '''
+ if isinstance(other, OrderedDict):
+ return dict.__eq__(self, other) and all(map(_eq, self, other))
+ return dict.__eq__(self, other)
+
+
+################################################################################
+### namedtuple
+################################################################################
+
+_class_template = """\
+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
+
+ @property
+ def __dict__(self):
+ 'A new OrderedDict mapping field names to their values'
+ return OrderedDict(zip(self._fields, self))
+
+ def _asdict(self):
+ 'Return a new OrderedDict which maps field names to their values.'
+ return self.__dict__
+
+ def __getnewargs__(self):
+ 'Return self as a plain tuple. Used by copy and pickle.'
+ return tuple(self)
+
+ def __getstate__(self):
+ 'Exclude the OrderedDict from pickling'
+ return None
+
+{field_defs}
+"""
+
+_repr_template = '{name}=%r'
+
+_field_template = '''\
+ {name} = _property(_itemgetter({index:d}), doc='Alias for field number {index:d}')
+'''
+
+def namedtuple(typename, field_names, verbose=False, rename=False):
+ """Returns 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 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)
+
+ """
+
+ # Validate the field names. At the user's option, either generate an error
+ # message or automatically replace the field name with a valid name.
+ if isinstance(field_names, str):
+ field_names = field_names.replace(',', ' ').split()
+ field_names = list(map(str, field_names))
+ if rename:
+ seen = set()
+ for index, name in enumerate(field_names):
+ if (not name.isidentifier()
+ or _iskeyword(name)
+ or name.startswith('_')
+ or name in seen):
+ field_names[index] = '_%d' % index
+ seen.add(name)
+ for name in [typename] + field_names:
+ if not name.isidentifier():
+ raise ValueError('Type names and field names must be valid '
+ 'identifiers: %r' % name)
+ if _iskeyword(name):
+ raise ValueError('Type names and field names cannot be a '
+ 'keyword: %r' % name)
+ seen = set()
+ for name in field_names:
+ if name.startswith('_') and not rename:
+ raise ValueError('Field names cannot start with an underscore: '
+ '%r' % name)
+ if name in seen:
+ raise ValueError('Encountered duplicate field name: %r' % name)
+ seen.add(name)
+
+ # Fill-in the class template
+ class_definition = _class_template.format(
+ typename = typename,
+ field_names = tuple(field_names),
+ num_fields = len(field_names),
+ arg_list = repr(tuple(field_names)).replace("'", "")[1:-1],
+ repr_fmt = ', '.join(_repr_template.format(name=name)
+ for name in field_names),
+ field_defs = '\n'.join(_field_template.format(index=index, name=name)
+ for index, name in enumerate(field_names))
+ )
+
+ # Execute the template string in a temporary namespace and support
+ # tracing utilities by setting a value for frame.f_globals['__name__']
+ namespace = dict(__name__='namedtuple_%s' % typename)
+ exec(class_definition, namespace)
+ result = namespace[typename]
+ result._source = class_definition
+ if verbose:
+ print(result._source)
+
+ # For pickling to work, the __module__ variable needs to be set to the frame
+ # where the named tuple is created. Bypass this step in environments where
+ # sys._getframe is not defined (Jython for example) or sys._getframe is not
+ # defined for arguments greater than 0 (IronPython).
+ try:
+ result.__module__ = _sys._getframe(1).f_globals.get('__name__', '__main__')
+ except (AttributeError, ValueError):
+ pass
+
+ return result
+
+
+########################################################################
+### Counter
+########################################################################
+
+def _count_elements(mapping, iterable):
+ 'Tally elements from the iterable.'
+ mapping_get = mapping.get
+ for elem in iterable:
+ mapping[elem] = mapping_get(elem, 0) + 1
+
+try: # Load C helper function if available
+ from _collections import _count_elements
+except ImportError:
+ pass
+
+class Counter(dict):
+ '''Dict subclass for counting hashable items. Sometimes called a bag
+ or multiset. Elements are stored as dictionary keys and their counts
+ are stored as dictionary values.
+
+ >>> 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)]
+
+ '''
+ # References:
+ # http://en.wikipedia.org/wiki/Multiset
+ # http://www.gnu.org/software/smalltalk/manual-base/html_node/Bag.html
+ # http://www.demo2s.com/Tutorial/Cpp/0380__set-multiset/Catalog0380__set-multiset.htm
+ # http://code.activestate.com/recipes/259174/
+ # Knuth, TAOCP Vol. II section 4.6.3
+
+ def __init__(self, iterable=None, **kwds):
+ '''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
+
+ '''
+ super().__init__()
+ self.update(iterable, **kwds)
+
+ def __missing__(self, key):
+ 'The count of elements not in the Counter is zero.'
+ # Needed so that self[missing_item] does not raise KeyError
+ return 0
+
+ def most_common(self, n=None):
+ '''List 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)]
+
+ '''
+ # Emulate Bag.sortedByCount from Smalltalk
+ if n is None:
+ return sorted(self.items(), key=_itemgetter(1), reverse=True)
+ return _heapq.nlargest(n, self.items(), key=_itemgetter(1))
+
+ def elements(self):
+ '''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.
+
+ '''
+ # Emulate Bag.do from Smalltalk and Multiset.begin from C++.
+ return _chain.from_iterable(_starmap(_repeat, self.items()))
+
+ # Override dict methods where necessary
+
+ @classmethod
+ def fromkeys(cls, iterable, v=None):
+ # There is no equivalent method for counters because setting v=1
+ # means that no element can have a count greater than one.
+ raise NotImplementedError(
+ 'Counter.fromkeys() is undefined. Use Counter(iterable) instead.')
+
+ def update(self, iterable=None, **kwds):
+ '''Like dict.update() but add counts instead of replacing them.
+
+ Source can be an iterable, a dictionary, or another Counter instance.
+
+ >>> 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
+
+ '''
+ # The regular dict.update() operation makes no sense here because the
+ # replace behavior results in the some of original untouched counts
+ # being mixed-in with all of the other counts for a mismash that
+ # doesn't have a straight-forward interpretation in most counting
+ # contexts. Instead, we implement straight-addition. Both the inputs
+ # and outputs are allowed to contain zero and negative counts.
+
+ if iterable is not None:
+ if isinstance(iterable, Mapping):
+ if self:
+ self_get = self.get
+ for elem, count in iterable.items():
+ self[elem] = count + self_get(elem, 0)
+ else:
+ super().update(iterable) # fast path when counter is empty
+ else:
+ _count_elements(self, iterable)
+ if kwds:
+ self.update(kwds)
+
+ def subtract(self, iterable=None, **kwds):
+ '''Like dict.update() but subtracts counts instead of replacing them.
+ Counts can be reduced below zero. Both the inputs and outputs are
+ allowed to contain zero and negative counts.
+
+ Source can be an iterable, a dictionary, or another Counter instance.
+
+ >>> 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
+
+ '''
+ if iterable is not None:
+ self_get = self.get
+ if isinstance(iterable, Mapping):
+ for elem, count in iterable.items():
+ self[elem] = self_get(elem, 0) - count
+ else:
+ for elem in iterable:
+ self[elem] = self_get(elem, 0) - 1
+ if kwds:
+ self.subtract(kwds)
+
+ def copy(self):
+ 'Return a shallow copy.'
+ return self.__class__(self)
+
+ def __reduce__(self):
+ return self.__class__, (dict(self),)
+
+ def __delitem__(self, elem):
+ 'Like dict.__delitem__() but does not raise KeyError for missing values.'
+ if elem in self:
+ super().__delitem__(elem)
+
+ def __repr__(self):
+ if not self:
+ return '%s()' % self.__class__.__name__
+ try:
+ items = ', '.join(map('%r: %r'.__mod__, self.most_common()))
+ return '%s({%s})' % (self.__class__.__name__, items)
+ except TypeError:
+ # handle case where values are not orderable
+ return '{0}({1!r})'.format(self.__class__.__name__, dict(self))
+
+ # Multiset-style mathematical operations discussed in:
+ # Knuth TAOCP Volume II section 4.6.3 exercise 19
+ # and at http://en.wikipedia.org/wiki/Multiset
+ #
+ # Outputs guaranteed to only include positive counts.
+ #
+ # To strip negative and zero counts, add-in an empty counter:
+ # c += Counter()
+
+ def __add__(self, other):
+ '''Add counts from two counters.
+
+ >>> Counter('abbb') + Counter('bcc')
+ Counter({'b': 4, 'c': 2, 'a': 1})
+
+ '''
+ if not isinstance(other, Counter):
+ return NotImplemented
+ result = Counter()
+ for elem, count in self.items():
+ newcount = count + other[elem]
+ if newcount > 0:
+ result[elem] = newcount
+ for elem, count in other.items():
+ if elem not in self and count > 0:
+ result[elem] = count
+ return result
+
+ def __sub__(self, other):
+ ''' Subtract count, but keep only results with positive counts.
+
+ >>> Counter('abbbc') - Counter('bccd')
+ Counter({'b': 2, 'a': 1})
+
+ '''
+ if not isinstance(other, Counter):
+ return NotImplemented
+ result = Counter()
+ for elem, count in self.items():
+ newcount = count - other[elem]
+ if newcount > 0:
+ result[elem] = newcount
+ for elem, count in other.items():
+ if elem not in self and count < 0:
+ result[elem] = 0 - count
+ return result
+
+ def __or__(self, other):
+ '''Union is the maximum of value in either of the input counters.
+
+ >>> Counter('abbb') | Counter('bcc')
+ Counter({'b': 3, 'c': 2, 'a': 1})
+
+ '''
+ if not isinstance(other, Counter):
+ return NotImplemented
+ result = Counter()
+ for elem, count in self.items():
+ other_count = other[elem]
+ newcount = other_count if count < other_count else count
+ if newcount > 0:
+ result[elem] = newcount
+ for elem, count in other.items():
+ if elem not in self and count > 0:
+ result[elem] = count
+ return result
+
+ def __and__(self, other):
+ ''' Intersection is the minimum of corresponding counts.
+
+ >>> Counter('abbb') & Counter('bcc')
+ Counter({'b': 1})
+
+ '''
+ if not isinstance(other, Counter):
+ return NotImplemented
+ result = Counter()
+ for elem, count in self.items():
+ other_count = other[elem]
+ newcount = count if count < other_count else other_count
+ if newcount > 0:
+ result[elem] = newcount
+ return result
+
+ def __pos__(self):
+ 'Adds an empty counter, effectively stripping negative and zero counts'
+ return self + Counter()
+
+ def __neg__(self):
+ '''Subtracts from an empty counter. Strips positive and zero counts,
+ and flips the sign on negative counts.
+
+ '''
+ return Counter() - self
+
+ def _keep_positive(self):
+ '''Internal method to strip elements with a negative or zero count'''
+ nonpositive = [elem for elem, count in self.items() if not count > 0]
+ for elem in nonpositive:
+ del self[elem]
+ return self
+
+ def __iadd__(self, other):
+ '''Inplace add from another counter, keeping only positive counts.
+
+ >>> c = Counter('abbb')
+ >>> c += Counter('bcc')
+ >>> c
+ Counter({'b': 4, 'c': 2, 'a': 1})
+
+ '''
+ for elem, count in other.items():
+ self[elem] += count
+ return self._keep_positive()
+
+ def __isub__(self, other):
+ '''Inplace subtract counter, but keep only results with positive counts.
+
+ >>> c = Counter('abbbc')
+ >>> c -= Counter('bccd')
+ >>> c
+ Counter({'b': 2, 'a': 1})
+
+ '''
+ for elem, count in other.items():
+ self[elem] -= count
+ return self._keep_positive()
+
+ def __ior__(self, other):
+ '''Inplace union is the maximum of value from either counter.
+
+ >>> c = Counter('abbb')
+ >>> c |= Counter('bcc')
+ >>> c
+ Counter({'b': 3, 'c': 2, 'a': 1})
+
+ '''
+ for elem, other_count in other.items():
+ count = self[elem]
+ if other_count > count:
+ self[elem] = other_count
+ return self._keep_positive()
+
+ def __iand__(self, other):
+ '''Inplace intersection is the minimum of corresponding counts.
+
+ >>> c = Counter('abbb')
+ >>> c &= Counter('bcc')
+ >>> c
+ Counter({'b': 1})
+
+ '''
+ for elem, count in self.items():
+ other_count = other[elem]
+ if other_count < count:
+ self[elem] = other_count
+ return self._keep_positive()
+
+
+########################################################################
+### ChainMap (helper for configparser and string.Template)
+########################################################################
+
+class ChainMap(MutableMapping):
+ ''' 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.
+
+ '''
+
+ def __init__(self, *maps):
+ '''Initialize a ChainMap by setting *maps* to the given mappings.
+ If no mappings are provided, a single empty dictionary is used.
+
+ '''
+ self.maps = list(maps) or [{}] # always at least one map
+
+ def __missing__(self, key):
+ raise KeyError(key)
+
+ def __getitem__(self, key):
+ for mapping in self.maps:
+ try:
+ return mapping[key] # can't use 'key in mapping' with defaultdict
+ except KeyError:
+ pass
+ return self.__missing__(key) # support subclasses that define __missing__
+
+ def get(self, key, default=None):
+ return self[key] if key in self else default
+
+ def __len__(self):
+ return len(set().union(*self.maps)) # reuses stored hash values if possible
+
+ def __iter__(self):
+ return iter(set().union(*self.maps))
+
+ def __contains__(self, key):
+ return any(key in m for m in self.maps)
+
+ def __bool__(self):
+ return any(self.maps)
+
+ @_recursive_repr()
+ def __repr__(self):
+ return '{0.__class__.__name__}({1})'.format(
+ self, ', '.join(map(repr, self.maps)))
+
+ @classmethod
+ def fromkeys(cls, iterable, *args):
+ 'Create a ChainMap with a single dict created from the iterable.'
+ return cls(dict.fromkeys(iterable, *args))
+
+ def copy(self):
+ 'New ChainMap or subclass with a new copy of maps[0] and refs to maps[1:]'
+ return self.__class__(self.maps[0].copy(), *self.maps[1:])
+
+ __copy__ = copy
+
+ def new_child(self, m=None): # like Django's Context.push()
+ '''
+ New ChainMap with a new map followed by all previous maps. If no
+ map is provided, an empty dict is used.
+ '''
+ if m is None:
+ m = {}
+ return self.__class__(m, *self.maps)
+
+ @property
+ def parents(self): # like Django's Context.pop()
+ 'New ChainMap from maps[1:].'
+ return self.__class__(*self.maps[1:])
+
+ def __setitem__(self, key, value):
+ self.maps[0][key] = value
+
+ def __delitem__(self, key):
+ try:
+ del self.maps[0][key]
+ except KeyError:
+ raise KeyError('Key not found in the first mapping: {!r}'.format(key))
+
+ def popitem(self):
+ 'Remove and return an item pair from maps[0]. Raise KeyError is maps[0] is empty.'
+ try:
+ return self.maps[0].popitem()
+ except KeyError:
+ raise KeyError('No keys found in the first mapping.')
+
+ def pop(self, key, *args):
+ 'Remove *key* from maps[0] and return its value. Raise KeyError if *key* not in maps[0].'
+ try:
+ return self.maps[0].pop(key, *args)
+ except KeyError:
+ raise KeyError('Key not found in the first mapping: {!r}'.format(key))
+
+ def clear(self):
+ 'Clear maps[0], leaving maps[1:] intact.'
+ self.maps[0].clear()
+
+
+################################################################################
+### UserDict
+################################################################################
+
+class UserDict(MutableMapping):
+
+ # Start by filling-out the abstract methods
+ def __init__(self, dict=None, **kwargs):
+ self.data = {}
+ if dict is not None:
+ self.update(dict)
+ if len(kwargs):
+ self.update(kwargs)
+ def __len__(self): return len(self.data)
+ def __getitem__(self, key):
+ if key in self.data:
+ return self.data[key]
+ if hasattr(self.__class__, "__missing__"):
+ return self.__class__.__missing__(self, key)
+ raise KeyError(key)
+ def __setitem__(self, key, item): self.data[key] = item
+ def __delitem__(self, key): del self.data[key]
+ def __iter__(self):
+ return iter(self.data)
+
+ # Modify __contains__ to work correctly when __missing__ is present
+ def __contains__(self, key):
+ return key in self.data
+
+ # Now, add the methods in dicts but not in MutableMapping
+ def __repr__(self): return repr(self.data)
+ def copy(self):
+ if self.__class__ is UserDict:
+ return UserDict(self.data.copy())
+ import copy
+ data = self.data
+ try:
+ self.data = {}
+ c = copy.copy(self)
+ finally:
+ self.data = data
+ c.update(self)
+ return c
+ @classmethod
+ def fromkeys(cls, iterable, value=None):
+ d = cls()
+ for key in iterable:
+ d[key] = value
+ return d
+
+
+
+################################################################################
+### UserList
+################################################################################
+
+class UserList(MutableSequence):
+ """A more or less complete user-defined wrapper around list objects."""
+ def __init__(self, initlist=None):
+ self.data = []
+ if initlist is not None:
+ # XXX should this accept an arbitrary sequence?
+ if type(initlist) == type(self.data):
+ self.data[:] = initlist
+ elif isinstance(initlist, UserList):
+ self.data[:] = initlist.data[:]
+ else:
+ self.data = list(initlist)
+ def __repr__(self): return repr(self.data)
+ def __lt__(self, other): return self.data < self.__cast(other)
+ def __le__(self, other): return self.data <= self.__cast(other)
+ def __eq__(self, other): return self.data == self.__cast(other)
+ def __ne__(self, other): return self.data != self.__cast(other)
+ def __gt__(self, other): return self.data > self.__cast(other)
+ def __ge__(self, other): return self.data >= self.__cast(other)
+ def __cast(self, other):
+ return other.data if isinstance(other, UserList) else other
+ def __contains__(self, item): return item in self.data
+ def __len__(self): return len(self.data)
+ def __getitem__(self, i): return self.data[i]
+ def __setitem__(self, i, item): self.data[i] = item
+ def __delitem__(self, i): del self.data[i]
+ def __add__(self, other):
+ if isinstance(other, UserList):
+ return self.__class__(self.data + other.data)
+ elif isinstance(other, type(self.data)):
+ return self.__class__(self.data + other)
+ return self.__class__(self.data + list(other))
+ def __radd__(self, other):
+ if isinstance(other, UserList):
+ return self.__class__(other.data + self.data)
+ elif isinstance(other, type(self.data)):
+ return self.__class__(other + self.data)
+ return self.__class__(list(other) + self.data)
+ def __iadd__(self, other):
+ if isinstance(other, UserList):
+ self.data += other.data
+ elif isinstance(other, type(self.data)):
+ self.data += other
+ else:
+ self.data += list(other)
+ return self
+ def __mul__(self, n):
+ return self.__class__(self.data*n)
+ __rmul__ = __mul__
+ def __imul__(self, n):
+ self.data *= n
+ return self
+ def append(self, item): self.data.append(item)
+ def insert(self, i, item): self.data.insert(i, item)
+ def pop(self, i=-1): return self.data.pop(i)
+ def remove(self, item): self.data.remove(item)
+ def clear(self): self.data.clear()
+ def copy(self): return self.__class__(self)
+ def count(self, item): return self.data.count(item)
+ def index(self, item, *args): return self.data.index(item, *args)
+ def reverse(self): self.data.reverse()
+ def sort(self, *args, **kwds): self.data.sort(*args, **kwds)
+ def extend(self, other):
+ if isinstance(other, UserList):
+ self.data.extend(other.data)
+ else:
+ self.data.extend(other)
+
+
+
+################################################################################
+### UserString
+################################################################################
+
+class UserString(Sequence):
+ def __init__(self, seq):
+ if isinstance(seq, str):
+ self.data = seq
+ elif isinstance(seq, UserString):
+ self.data = seq.data[:]
+ else:
+ self.data = str(seq)
+ def __str__(self): return str(self.data)
+ def __repr__(self): return repr(self.data)
+ def __int__(self): return int(self.data)
+ def __float__(self): return float(self.data)
+ def __complex__(self): return complex(self.data)
+ def __hash__(self): return hash(self.data)
+
+ def __eq__(self, string):
+ if isinstance(string, UserString):
+ return self.data == string.data
+ return self.data == string
+ def __ne__(self, string):
+ if isinstance(string, UserString):
+ return self.data != string.data
+ return self.data != string
+ def __lt__(self, string):
+ if isinstance(string, UserString):
+ return self.data < string.data
+ return self.data < string
+ def __le__(self, string):
+ if isinstance(string, UserString):
+ return self.data <= string.data
+ return self.data <= string
+ def __gt__(self, string):
+ if isinstance(string, UserString):
+ return self.data > string.data
+ return self.data > string
+ def __ge__(self, string):
+ if isinstance(string, UserString):
+ return self.data >= string.data
+ return self.data >= string
+
+ def __contains__(self, char):
+ if isinstance(char, UserString):
+ char = char.data
+ return char in self.data
+
+ def __len__(self): return len(self.data)
+ def __getitem__(self, index): return self.__class__(self.data[index])
+ def __add__(self, other):
+ if isinstance(other, UserString):
+ return self.__class__(self.data + other.data)
+ elif isinstance(other, str):
+ return self.__class__(self.data + other)
+ return self.__class__(self.data + str(other))
+ def __radd__(self, other):
+ if isinstance(other, str):
+ return self.__class__(other + self.data)
+ return self.__class__(str(other) + self.data)
+ def __mul__(self, n):
+ return self.__class__(self.data*n)
+ __rmul__ = __mul__
+ def __mod__(self, args):
+ return self.__class__(self.data % args)
+
+ # the following methods are defined in alphabetical order:
+ def capitalize(self): return self.__class__(self.data.capitalize())
+ def center(self, width, *args):
+ return self.__class__(self.data.center(width, *args))
+ def count(self, sub, start=0, end=_sys.maxsize):
+ if isinstance(sub, UserString):
+ sub = sub.data
+ return self.data.count(sub, start, end)
+ def encode(self, encoding=None, errors=None): # XXX improve this?
+ if encoding:
+ if errors:
+ return self.__class__(self.data.encode(encoding, errors))
+ return self.__class__(self.data.encode(encoding))
+ return self.__class__(self.data.encode())
+ def endswith(self, suffix, start=0, end=_sys.maxsize):
+ return self.data.endswith(suffix, start, end)
+ def expandtabs(self, tabsize=8):
+ return self.__class__(self.data.expandtabs(tabsize))
+ def find(self, sub, start=0, end=_sys.maxsize):
+ if isinstance(sub, UserString):
+ sub = sub.data
+ return self.data.find(sub, start, end)
+ def format(self, *args, **kwds):
+ return self.data.format(*args, **kwds)
+ def index(self, sub, start=0, end=_sys.maxsize):
+ return self.data.index(sub, start, end)
+ def isalpha(self): return self.data.isalpha()
+ def isalnum(self): return self.data.isalnum()
+ def isdecimal(self): return self.data.isdecimal()
+ def isdigit(self): return self.data.isdigit()
+ def isidentifier(self): return self.data.isidentifier()
+ def islower(self): return self.data.islower()
+ def isnumeric(self): return self.data.isnumeric()
+ def isspace(self): return self.data.isspace()
+ def istitle(self): return self.data.istitle()
+ def isupper(self): return self.data.isupper()
+ def join(self, seq): return self.data.join(seq)
+ def ljust(self, width, *args):
+ return self.__class__(self.data.ljust(width, *args))
+ def lower(self): return self.__class__(self.data.lower())
+ def lstrip(self, chars=None): return self.__class__(self.data.lstrip(chars))
+ def partition(self, sep):
+ return self.data.partition(sep)
+ def replace(self, old, new, maxsplit=-1):
+ if isinstance(old, UserString):
+ old = old.data
+ if isinstance(new, UserString):
+ new = new.data
+ return self.__class__(self.data.replace(old, new, maxsplit))
+ def rfind(self, sub, start=0, end=_sys.maxsize):
+ if isinstance(sub, UserString):
+ sub = sub.data
+ return self.data.rfind(sub, start, end)
+ def rindex(self, sub, start=0, end=_sys.maxsize):
+ return self.data.rindex(sub, start, end)
+ def rjust(self, width, *args):
+ return self.__class__(self.data.rjust(width, *args))
+ def rpartition(self, sep):
+ return self.data.rpartition(sep)
+ def rstrip(self, chars=None):
+ return self.__class__(self.data.rstrip(chars))
+ def split(self, sep=None, maxsplit=-1):
+ return self.data.split(sep, maxsplit)
+ def rsplit(self, sep=None, maxsplit=-1):
+ return self.data.rsplit(sep, maxsplit)
+ def splitlines(self, keepends=False): return self.data.splitlines(keepends)
+ def startswith(self, prefix, start=0, end=_sys.maxsize):
+ return self.data.startswith(prefix, start, end)
+ def strip(self, chars=None): return self.__class__(self.data.strip(chars))
+ def swapcase(self): return self.__class__(self.data.swapcase())
+ def title(self): return self.__class__(self.data.title())
+ def translate(self, *args):
+ return self.__class__(self.data.translate(*args))
+ def upper(self): return self.__class__(self.data.upper())
+ def zfill(self, width): return self.__class__(self.data.zfill(width))
--- /dev/null
+################################################################################
+### Simple tests
+################################################################################
+
+# verify that instances can be pickled
+from collections import namedtuple
+from pickle import loads, dumps
+Point = namedtuple('Point', 'x, y', True)
+p = Point(x=10, y=20)
+assert p == loads(dumps(p))
+
+# test and demonstrate ability to override methods
+class Point(namedtuple('Point', 'x y')):
+ __slots__ = ()
+ @property
+ def hypot(self):
+ return (self.x ** 2 + self.y ** 2) ** 0.5
+ def __str__(self):
+ return 'Point: x=%6.3f y=%6.3f hypot=%6.3f' % (self.x, self.y, self.hypot)
+
+for p in Point(3, 4), Point(14, 5/7.):
+ print (p)
+
+class Point(namedtuple('Point', 'x y')):
+ 'Point class with optimized _make() and _replace() without error-checking'
+ __slots__ = ()
+ _make = classmethod(tuple.__new__)
+ def _replace(self, _map=map, **kwds):
+ return self._make(_map(kwds.get, ('x', 'y'), self))
+
+print(Point(11, 22)._replace(x=100))
+
+Point3D = namedtuple('Point3D', Point._fields + ('z',))
+print(Point3D.__doc__)
+
+import doctest, collections
+TestResults = namedtuple('TestResults', 'failed attempted')
+print(TestResults(*doctest.testmod(collections)))
--- /dev/null
+from _collections_abc import *
+from _collections_abc import __all__
--- /dev/null
+"""Concrete date/time and related types.
+
+See http://www.iana.org/time-zones/repository/tz-link.html for
+time zone and DST data sources.
+"""
+
+import time as _time
+import math as _math
+
+def _cmp(x, y):
+ return 0 if x == y else 1 if x > y else -1
+
+MINYEAR = 1
+MAXYEAR = 9999
+_MAXORDINAL = 3652059 # date.max.toordinal()
+
+# Utility functions, adapted from Python's Demo/classes/Dates.py, which
+# also assumes the current Gregorian calendar indefinitely extended in
+# both directions. Difference: Dates.py calls January 1 of year 0 day
+# number 1. The code here calls January 1 of year 1 day number 1. This is
+# to match the definition of the "proleptic Gregorian" calendar in Dershowitz
+# and Reingold's "Calendrical Calculations", where it's the base calendar
+# for all computations. See the book for algorithms for converting between
+# proleptic Gregorian ordinals and many other calendar systems.
+
+# -1 is a placeholder for indexing purposes.
+_DAYS_IN_MONTH = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
+
+_DAYS_BEFORE_MONTH = [-1] # -1 is a placeholder for indexing purposes.
+dbm = 0
+for dim in _DAYS_IN_MONTH[1:]:
+ _DAYS_BEFORE_MONTH.append(dbm)
+ dbm += dim
+del dbm, dim
+
+def _is_leap(year):
+ "year -> 1 if leap year, else 0."
+ return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)
+
+def _days_before_year(year):
+ "year -> number of days before January 1st of year."
+ y = year - 1
+ return y*365 + y//4 - y//100 + y//400
+
+def _days_in_month(year, month):
+ "year, month -> number of days in that month in that year."
+ assert 1 <= month <= 12, month
+ if month == 2 and _is_leap(year):
+ return 29
+ return _DAYS_IN_MONTH[month]
+
+def _days_before_month(year, month):
+ "year, month -> number of days in year preceding first day of month."
+ assert 1 <= month <= 12, 'month must be in 1..12'
+ return _DAYS_BEFORE_MONTH[month] + (month > 2 and _is_leap(year))
+
+def _ymd2ord(year, month, day):
+ "year, month, day -> ordinal, considering 01-Jan-0001 as day 1."
+ assert 1 <= month <= 12, 'month must be in 1..12'
+ dim = _days_in_month(year, month)
+ assert 1 <= day <= dim, ('day must be in 1..%d' % dim)
+ return (_days_before_year(year) +
+ _days_before_month(year, month) +
+ day)
+
+_DI400Y = _days_before_year(401) # number of days in 400 years
+_DI100Y = _days_before_year(101) # " " " " 100 "
+_DI4Y = _days_before_year(5) # " " " " 4 "
+
+# A 4-year cycle has an extra leap day over what we'd get from pasting
+# together 4 single years.
+assert _DI4Y == 4 * 365 + 1
+
+# Similarly, a 400-year cycle has an extra leap day over what we'd get from
+# pasting together 4 100-year cycles.
+assert _DI400Y == 4 * _DI100Y + 1
+
+# OTOH, a 100-year cycle has one fewer leap day than we'd get from
+# pasting together 25 4-year cycles.
+assert _DI100Y == 25 * _DI4Y - 1
+
+def _ord2ymd(n):
+ "ordinal -> (year, month, day), considering 01-Jan-0001 as day 1."
+
+ # n is a 1-based index, starting at 1-Jan-1. The pattern of leap years
+ # repeats exactly every 400 years. The basic strategy is to find the
+ # closest 400-year boundary at or before n, then work with the offset
+ # from that boundary to n. Life is much clearer if we subtract 1 from
+ # n first -- then the values of n at 400-year boundaries are exactly
+ # those divisible by _DI400Y:
+ #
+ # D M Y n n-1
+ # -- --- ---- ---------- ----------------
+ # 31 Dec -400 -_DI400Y -_DI400Y -1
+ # 1 Jan -399 -_DI400Y +1 -_DI400Y 400-year boundary
+ # ...
+ # 30 Dec 000 -1 -2
+ # 31 Dec 000 0 -1
+ # 1 Jan 001 1 0 400-year boundary
+ # 2 Jan 001 2 1
+ # 3 Jan 001 3 2
+ # ...
+ # 31 Dec 400 _DI400Y _DI400Y -1
+ # 1 Jan 401 _DI400Y +1 _DI400Y 400-year boundary
+ n -= 1
+ n400, n = divmod(n, _DI400Y)
+ year = n400 * 400 + 1 # ..., -399, 1, 401, ...
+
+ # Now n is the (non-negative) offset, in days, from January 1 of year, to
+ # the desired date. Now compute how many 100-year cycles precede n.
+ # Note that it's possible for n100 to equal 4! In that case 4 full
+ # 100-year cycles precede the desired day, which implies the desired
+ # day is December 31 at the end of a 400-year cycle.
+ n100, n = divmod(n, _DI100Y)
+
+ # Now compute how many 4-year cycles precede it.
+ n4, n = divmod(n, _DI4Y)
+
+ # And now how many single years. Again n1 can be 4, and again meaning
+ # that the desired day is December 31 at the end of the 4-year cycle.
+ n1, n = divmod(n, 365)
+
+ year += n100 * 100 + n4 * 4 + n1
+ if n1 == 4 or n100 == 4:
+ assert n == 0
+ return year-1, 12, 31
+
+ # Now the year is correct, and n is the offset from January 1. We find
+ # the month via an estimate that's either exact or one too large.
+ leapyear = n1 == 3 and (n4 != 24 or n100 == 3)
+ assert leapyear == _is_leap(year)
+ month = (n + 50) >> 5
+ preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 and leapyear)
+ if preceding > n: # estimate is too large
+ month -= 1
+ preceding -= _DAYS_IN_MONTH[month] + (month == 2 and leapyear)
+ n -= preceding
+ assert 0 <= n < _days_in_month(year, month)
+
+ # Now the year and month are correct, and n is the offset from the
+ # start of that month: we're done!
+ return year, month, n+1
+
+# Month and day names. For localized versions, see the calendar module.
+_MONTHNAMES = [None, "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"]
+_DAYNAMES = [None, "Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
+
+
+def _build_struct_time(y, m, d, hh, mm, ss, dstflag):
+ wday = (_ymd2ord(y, m, d) + 6) % 7
+ dnum = _days_before_month(y, m) + d
+ return _time.struct_time((y, m, d, hh, mm, ss, wday, dnum, dstflag))
+
+def _format_time(hh, mm, ss, us):
+ # Skip trailing microseconds when us==0.
+ result = "%02d:%02d:%02d" % (hh, mm, ss)
+ if us:
+ result += ".%06d" % us
+ return result
+
+# Correctly substitute for %z and %Z escapes in strftime formats.
+def _wrap_strftime(object, format, timetuple):
+ # Don't call utcoffset() or tzname() unless actually needed.
+ freplace = None # the string to use for %f
+ zreplace = None # the string to use for %z
+ Zreplace = None # the string to use for %Z
+
+ # Scan format for %z and %Z escapes, replacing as needed.
+ newformat = []
+ push = newformat.append
+ i, n = 0, len(format)
+ while i < n:
+ ch = format[i]
+ i += 1
+ if ch == '%':
+ if i < n:
+ ch = format[i]
+ i += 1
+ if ch == 'f':
+ if freplace is None:
+ freplace = '%06d' % getattr(object,
+ 'microsecond', 0)
+ newformat.append(freplace)
+ elif ch == 'z':
+ if zreplace is None:
+ zreplace = ""
+ if hasattr(object, "utcoffset"):
+ offset = object.utcoffset()
+ if offset is not None:
+ sign = '+'
+ if offset.days < 0:
+ offset = -offset
+ sign = '-'
+ h, m = divmod(offset, timedelta(hours=1))
+ assert not m % timedelta(minutes=1), "whole minute"
+ m //= timedelta(minutes=1)
+ zreplace = '%c%02d%02d' % (sign, h, m)
+ assert '%' not in zreplace
+ newformat.append(zreplace)
+ elif ch == 'Z':
+ if Zreplace is None:
+ Zreplace = ""
+ if hasattr(object, "tzname"):
+ s = object.tzname()
+ if s is not None:
+ # strftime is going to have at this: escape %
+ Zreplace = s.replace('%', '%%')
+ newformat.append(Zreplace)
+ else:
+ push('%')
+ push(ch)
+ else:
+ push('%')
+ else:
+ push(ch)
+ newformat = "".join(newformat)
+ return _time.strftime(newformat, timetuple)
+
+def _call_tzinfo_method(tzinfo, methname, tzinfoarg):
+ if tzinfo is None:
+ return None
+ return getattr(tzinfo, methname)(tzinfoarg)
+
+# Just raise TypeError if the arg isn't None or a string.
+def _check_tzname(name):
+ if name is not None and not isinstance(name, str):
+ raise TypeError("tzinfo.tzname() must return None or string, "
+ "not '%s'" % type(name))
+
+# name is the offset-producing method, "utcoffset" or "dst".
+# offset is what it returned.
+# If offset isn't None or timedelta, raises TypeError.
+# If offset is None, returns None.
+# Else offset is checked for being in range, and a whole # of minutes.
+# If it is, its integer value is returned. Else ValueError is raised.
+def _check_utc_offset(name, offset):
+ assert name in ("utcoffset", "dst")
+ if offset is None:
+ return
+ if not isinstance(offset, timedelta):
+ raise TypeError("tzinfo.%s() must return None "
+ "or timedelta, not '%s'" % (name, type(offset)))
+ if offset % timedelta(minutes=1) or offset.microseconds:
+ raise ValueError("tzinfo.%s() must return a whole number "
+ "of minutes, got %s" % (name, offset))
+ if not -timedelta(1) < offset < timedelta(1):
+ raise ValueError("%s()=%s, must be must be strictly between"
+ " -timedelta(hours=24) and timedelta(hours=24)"
+ % (name, offset))
+
+def _check_date_fields(year, month, day):
+ if not isinstance(year, int):
+ raise TypeError('int expected')
+ if not MINYEAR <= year <= MAXYEAR:
+ raise ValueError('year must be in %d..%d' % (MINYEAR, MAXYEAR), year)
+ if not 1 <= month <= 12:
+ raise ValueError('month must be in 1..12', month)
+ dim = _days_in_month(year, month)
+ if not 1 <= day <= dim:
+ raise ValueError('day must be in 1..%d' % dim, day)
+
+def _check_time_fields(hour, minute, second, microsecond):
+ if not isinstance(hour, int):
+ raise TypeError('int expected')
+ if not 0 <= hour <= 23:
+ raise ValueError('hour must be in 0..23', hour)
+ if not 0 <= minute <= 59:
+ raise ValueError('minute must be in 0..59', minute)
+ if not 0 <= second <= 59:
+ raise ValueError('second must be in 0..59', second)
+ if not 0 <= microsecond <= 999999:
+ raise ValueError('microsecond must be in 0..999999', microsecond)
+
+def _check_tzinfo_arg(tz):
+ if tz is not None and not isinstance(tz, tzinfo):
+ raise TypeError("tzinfo argument must be None or of a tzinfo subclass")
+
+def _cmperror(x, y):
+ raise TypeError("can't compare '%s' to '%s'" % (
+ type(x).__name__, type(y).__name__))
+
+class timedelta:
+ """Represent the difference between two datetime objects.
+
+ Supported operators:
+
+ - add, subtract timedelta
+ - unary plus, minus, abs
+ - compare to timedelta
+ - multiply, divide by int
+
+ In addition, datetime supports subtraction of two datetime objects
+ returning a timedelta, and addition or subtraction of a datetime
+ and a timedelta giving a datetime.
+
+ Representation: (days, seconds, microseconds). Why? Because I
+ felt like it.
+ """
+ __slots__ = '_days', '_seconds', '_microseconds'
+
+ def __new__(cls, days=0, seconds=0, microseconds=0,
+ milliseconds=0, minutes=0, hours=0, weeks=0):
+ # Doing this efficiently and accurately in C is going to be difficult
+ # and error-prone, due to ubiquitous overflow possibilities, and that
+ # C double doesn't have enough bits of precision to represent
+ # microseconds over 10K years faithfully. The code here tries to make
+ # explicit where go-fast assumptions can be relied on, in order to
+ # guide the C implementation; it's way more convoluted than speed-
+ # ignoring auto-overflow-to-long idiomatic Python could be.
+
+ # XXX Check that all inputs are ints or floats.
+
+ # Final values, all integer.
+ # s and us fit in 32-bit signed ints; d isn't bounded.
+ d = s = us = 0
+
+ # Normalize everything to days, seconds, microseconds.
+ days += weeks*7
+ seconds += minutes*60 + hours*3600
+ microseconds += milliseconds*1000
+
+ # Get rid of all fractions, and normalize s and us.
+ # Take a deep breath <wink>.
+ if isinstance(days, float):
+ dayfrac, days = _math.modf(days)
+ daysecondsfrac, daysecondswhole = _math.modf(dayfrac * (24.*3600.))
+ assert daysecondswhole == int(daysecondswhole) # can't overflow
+ s = int(daysecondswhole)
+ assert days == int(days)
+ d = int(days)
+ else:
+ daysecondsfrac = 0.0
+ d = days
+ assert isinstance(daysecondsfrac, float)
+ assert abs(daysecondsfrac) <= 1.0
+ assert isinstance(d, int)
+ assert abs(s) <= 24 * 3600
+ # days isn't referenced again before redefinition
+
+ if isinstance(seconds, float):
+ secondsfrac, seconds = _math.modf(seconds)
+ assert seconds == int(seconds)
+ seconds = int(seconds)
+ secondsfrac += daysecondsfrac
+ assert abs(secondsfrac) <= 2.0
+ else:
+ secondsfrac = daysecondsfrac
+ # daysecondsfrac isn't referenced again
+ assert isinstance(secondsfrac, float)
+ assert abs(secondsfrac) <= 2.0
+
+ assert isinstance(seconds, int)
+ days, seconds = divmod(seconds, 24*3600)
+ d += days
+ s += int(seconds) # can't overflow
+ assert isinstance(s, int)
+ assert abs(s) <= 2 * 24 * 3600
+ # seconds isn't referenced again before redefinition
+
+ usdouble = secondsfrac * 1e6
+ assert abs(usdouble) < 2.1e6 # exact value not critical
+ # secondsfrac isn't referenced again
+
+ if isinstance(microseconds, float):
+ microseconds += usdouble
+ microseconds = round(microseconds, 0)
+ seconds, microseconds = divmod(microseconds, 1e6)
+ assert microseconds == int(microseconds)
+ assert seconds == int(seconds)
+ days, seconds = divmod(seconds, 24.*3600.)
+ assert days == int(days)
+ assert seconds == int(seconds)
+ d += int(days)
+ s += int(seconds) # can't overflow
+ assert isinstance(s, int)
+ assert abs(s) <= 3 * 24 * 3600
+ else:
+ seconds, microseconds = divmod(microseconds, 1000000)
+ days, seconds = divmod(seconds, 24*3600)
+ d += days
+ s += int(seconds) # can't overflow
+ assert isinstance(s, int)
+ assert abs(s) <= 3 * 24 * 3600
+ microseconds = float(microseconds)
+ microseconds += usdouble
+ microseconds = round(microseconds, 0)
+ assert abs(s) <= 3 * 24 * 3600
+ assert abs(microseconds) < 3.1e6
+
+ # Just a little bit of carrying possible for microseconds and seconds.
+ assert isinstance(microseconds, float)
+ assert int(microseconds) == microseconds
+ us = int(microseconds)
+ seconds, us = divmod(us, 1000000)
+ s += seconds # cant't overflow
+ assert isinstance(s, int)
+ days, s = divmod(s, 24*3600)
+ d += days
+
+ assert isinstance(d, int)
+ assert isinstance(s, int) and 0 <= s < 24*3600
+ assert isinstance(us, int) and 0 <= us < 1000000
+
+ self = object.__new__(cls)
+
+ self._days = d
+ self._seconds = s
+ self._microseconds = us
+ if abs(d) > 999999999:
+ raise OverflowError("timedelta # of days is too large: %d" % d)
+
+ return self
+
+ def __repr__(self):
+ if self._microseconds:
+ return "%s(%d, %d, %d)" % ('datetime.' + self.__class__.__name__,
+ self._days,
+ self._seconds,
+ self._microseconds)
+ if self._seconds:
+ return "%s(%d, %d)" % ('datetime.' + self.__class__.__name__,
+ self._days,
+ self._seconds)
+ return "%s(%d)" % ('datetime.' + self.__class__.__name__, self._days)
+
+ def __str__(self):
+ mm, ss = divmod(self._seconds, 60)
+ hh, mm = divmod(mm, 60)
+ s = "%d:%02d:%02d" % (hh, mm, ss)
+ if self._days:
+ def plural(n):
+ return n, abs(n) != 1 and "s" or ""
+ s = ("%d day%s, " % plural(self._days)) + s
+ if self._microseconds:
+ s = s + ".%06d" % self._microseconds
+ return s
+
+ def total_seconds(self):
+ """Total seconds in the duration."""
+ return ((self.days * 86400 + self.seconds)*10**6 +
+ self.microseconds) / 10**6
+
+ # Read-only field accessors
+ @property
+ def days(self):
+ """days"""
+ return self._days
+
+ @property
+ def seconds(self):
+ """seconds"""
+ return self._seconds
+
+ @property
+ def microseconds(self):
+ """microseconds"""
+ return self._microseconds
+
+ def __add__(self, other):
+ if isinstance(other, timedelta):
+ # for CPython compatibility, we cannot use
+ # our __class__ here, but need a real timedelta
+ return timedelta(self._days + other._days,
+ self._seconds + other._seconds,
+ self._microseconds + other._microseconds)
+ return NotImplemented
+
+ __radd__ = __add__
+
+ def __sub__(self, other):
+ if isinstance(other, timedelta):
+ # for CPython compatibility, we cannot use
+ # our __class__ here, but need a real timedelta
+ return timedelta(self._days - other._days,
+ self._seconds - other._seconds,
+ self._microseconds - other._microseconds)
+ return NotImplemented
+
+ def __rsub__(self, other):
+ if isinstance(other, timedelta):
+ return -self + other
+ return NotImplemented
+
+ def __neg__(self):
+ # for CPython compatibility, we cannot use
+ # our __class__ here, but need a real timedelta
+ return timedelta(-self._days,
+ -self._seconds,
+ -self._microseconds)
+
+ def __pos__(self):
+ return self
+
+ def __abs__(self):
+ if self._days < 0:
+ return -self
+ else:
+ return self
+
+ def __mul__(self, other):
+ if isinstance(other, int):
+ # for CPython compatibility, we cannot use
+ # our __class__ here, but need a real timedelta
+ return timedelta(self._days * other,
+ self._seconds * other,
+ self._microseconds * other)
+ if isinstance(other, float):
+ a, b = other.as_integer_ratio()
+ return self * a / b
+ return NotImplemented
+
+ __rmul__ = __mul__
+
+ def _to_microseconds(self):
+ return ((self._days * (24*3600) + self._seconds) * 1000000 +
+ self._microseconds)
+
+ def __floordiv__(self, other):
+ if not isinstance(other, (int, timedelta)):
+ return NotImplemented
+ usec = self._to_microseconds()
+ if isinstance(other, timedelta):
+ return usec // other._to_microseconds()
+ if isinstance(other, int):
+ return timedelta(0, 0, usec // other)
+
+ def __truediv__(self, other):
+ if not isinstance(other, (int, float, timedelta)):
+ return NotImplemented
+ usec = self._to_microseconds()
+ if isinstance(other, timedelta):
+ return usec / other._to_microseconds()
+ if isinstance(other, int):
+ return timedelta(0, 0, usec / other)
+ if isinstance(other, float):
+ a, b = other.as_integer_ratio()
+ return timedelta(0, 0, b * usec / a)
+
+ def __mod__(self, other):
+ if isinstance(other, timedelta):
+ r = self._to_microseconds() % other._to_microseconds()
+ return timedelta(0, 0, r)
+ return NotImplemented
+
+ def __divmod__(self, other):
+ if isinstance(other, timedelta):
+ q, r = divmod(self._to_microseconds(),
+ other._to_microseconds())
+ return q, timedelta(0, 0, r)
+ return NotImplemented
+
+ # Comparisons of timedelta objects with other.
+
+ def __eq__(self, other):
+ if isinstance(other, timedelta):
+ return self._cmp(other) == 0
+ else:
+ return False
+
+ def __ne__(self, other):
+ if isinstance(other, timedelta):
+ return self._cmp(other) != 0
+ else:
+ return True
+
+ def __le__(self, other):
+ if isinstance(other, timedelta):
+ return self._cmp(other) <= 0
+ else:
+ _cmperror(self, other)
+
+ def __lt__(self, other):
+ if isinstance(other, timedelta):
+ return self._cmp(other) < 0
+ else:
+ _cmperror(self, other)
+
+ def __ge__(self, other):
+ if isinstance(other, timedelta):
+ return self._cmp(other) >= 0
+ else:
+ _cmperror(self, other)
+
+ def __gt__(self, other):
+ if isinstance(other, timedelta):
+ return self._cmp(other) > 0
+ else:
+ _cmperror(self, other)
+
+ def _cmp(self, other):
+ assert isinstance(other, timedelta)
+ return _cmp(self._getstate(), other._getstate())
+
+ def __hash__(self):
+ return hash(self._getstate())
+
+ def __bool__(self):
+ return (self._days != 0 or
+ self._seconds != 0 or
+ self._microseconds != 0)
+
+ # Pickle support.
+
+ def _getstate(self):
+ return (self._days, self._seconds, self._microseconds)
+
+ def __reduce__(self):
+ return (self.__class__, self._getstate())
+
+timedelta.min = timedelta(-999999999)
+timedelta.max = timedelta(days=999999999, hours=23, minutes=59, seconds=59,
+ microseconds=999999)
+timedelta.resolution = timedelta(microseconds=1)
+
+class date:
+ """Concrete date type.
+
+ Constructors:
+
+ __new__()
+ fromtimestamp()
+ today()
+ fromordinal()
+
+ Operators:
+
+ __repr__, __str__
+ __cmp__, __hash__
+ __add__, __radd__, __sub__ (add/radd only with timedelta arg)
+
+ Methods:
+
+ timetuple()
+ toordinal()
+ weekday()
+ isoweekday(), isocalendar(), isoformat()
+ ctime()
+ strftime()
+
+ Properties (readonly):
+ year, month, day
+ """
+ __slots__ = '_year', '_month', '_day'
+
+ def __new__(cls, year, month=None, day=None):
+ """Constructor.
+
+ Arguments:
+
+ year, month, day (required, base 1)
+ """
+ if (isinstance(year, bytes) and len(year) == 4 and
+ 1 <= year[2] <= 12 and month is None): # Month is sane
+ # Pickle support
+ self = object.__new__(cls)
+ self.__setstate(year)
+ return self
+ _check_date_fields(year, month, day)
+ self = object.__new__(cls)
+ self._year = year
+ self._month = month
+ self._day = day
+ return self
+
+ # Additional constructors
+
+ @classmethod
+ def fromtimestamp(cls, t):
+ "Construct a date from a POSIX timestamp (like time.time())."
+ y, m, d, hh, mm, ss, weekday, jday, dst = _time.localtime(t)
+ return cls(y, m, d)
+
+ @classmethod
+ def today(cls):
+ "Construct a date from time.time()."
+ t = _time.time()
+ return cls.fromtimestamp(t)
+
+ @classmethod
+ def fromordinal(cls, n):
+ """Contruct a date from a proleptic Gregorian ordinal.
+
+ January 1 of year 1 is day 1. Only the year, month and day are
+ non-zero in the result.
+ """
+ y, m, d = _ord2ymd(n)
+ return cls(y, m, d)
+
+ # Conversions to string
+
+ def __repr__(self):
+ """Convert to formal string, for repr().
+
+ >>> dt = datetime(2010, 1, 1)
+ >>> repr(dt)
+ 'datetime.datetime(2010, 1, 1, 0, 0)'
+
+ >>> dt = datetime(2010, 1, 1, tzinfo=timezone.utc)
+ >>> repr(dt)
+ 'datetime.datetime(2010, 1, 1, 0, 0, tzinfo=datetime.timezone.utc)'
+ """
+ return "%s(%d, %d, %d)" % ('datetime.' + self.__class__.__name__,
+ self._year,
+ self._month,
+ self._day)
+ # XXX These shouldn't depend on time.localtime(), because that
+ # clips the usable dates to [1970 .. 2038). At least ctime() is
+ # easily done without using strftime() -- that's better too because
+ # strftime("%c", ...) is locale specific.
+
+
+ def ctime(self):
+ "Return ctime() style string."
+ weekday = self.toordinal() % 7 or 7
+ return "%s %s %2d 00:00:00 %04d" % (
+ _DAYNAMES[weekday],
+ _MONTHNAMES[self._month],
+ self._day, self._year)
+
+ def strftime(self, fmt):
+ "Format using strftime()."
+ return _wrap_strftime(self, fmt, self.timetuple())
+
+ def __format__(self, fmt):
+ if len(fmt) != 0:
+ return self.strftime(fmt)
+ return str(self)
+
+ def isoformat(self):
+ """Return the date formatted according to ISO.
+
+ This is 'YYYY-MM-DD'.
+
+ References:
+ - http://www.w3.org/TR/NOTE-datetime
+ - http://www.cl.cam.ac.uk/~mgk25/iso-time.html
+ """
+ return "%04d-%02d-%02d" % (self._year, self._month, self._day)
+
+ __str__ = isoformat
+
+ # Read-only field accessors
+ @property
+ def year(self):
+ """year (1-9999)"""
+ return self._year
+
+ @property
+ def month(self):
+ """month (1-12)"""
+ return self._month
+
+ @property
+ def day(self):
+ """day (1-31)"""
+ return self._day
+
+ # Standard conversions, __cmp__, __hash__ (and helpers)
+
+ def timetuple(self):
+ "Return local time tuple compatible with time.localtime()."
+ return _build_struct_time(self._year, self._month, self._day,
+ 0, 0, 0, -1)
+
+ def toordinal(self):
+ """Return proleptic Gregorian ordinal for the year, month and day.
+
+ January 1 of year 1 is day 1. Only the year, month and day values
+ contribute to the result.
+ """
+ return _ymd2ord(self._year, self._month, self._day)
+
+ def replace(self, year=None, month=None, day=None):
+ """Return a new date with new values for the specified fields."""
+ if year is None:
+ year = self._year
+ if month is None:
+ month = self._month
+ if day is None:
+ day = self._day
+ _check_date_fields(year, month, day)
+ return date(year, month, day)
+
+ # Comparisons of date objects with other.
+
+ def __eq__(self, other):
+ if isinstance(other, date):
+ return self._cmp(other) == 0
+ return NotImplemented
+
+ def __ne__(self, other):
+ if isinstance(other, date):
+ return self._cmp(other) != 0
+ return NotImplemented
+
+ def __le__(self, other):
+ if isinstance(other, date):
+ return self._cmp(other) <= 0
+ return NotImplemented
+
+ def __lt__(self, other):
+ if isinstance(other, date):
+ return self._cmp(other) < 0
+ return NotImplemented
+
+ def __ge__(self, other):
+ if isinstance(other, date):
+ return self._cmp(other) >= 0
+ return NotImplemented
+
+ def __gt__(self, other):
+ if isinstance(other, date):
+ return self._cmp(other) > 0
+ return NotImplemented
+
+ def _cmp(self, other):
+ assert isinstance(other, date)
+ y, m, d = self._year, self._month, self._day
+ y2, m2, d2 = other._year, other._month, other._day
+ return _cmp((y, m, d), (y2, m2, d2))
+
+ def __hash__(self):
+ "Hash."
+ return hash(self._getstate())
+
+ # Computations
+
+ def __add__(self, other):
+ "Add a date to a timedelta."
+ if isinstance(other, timedelta):
+ o = self.toordinal() + other.days
+ if 0 < o <= _MAXORDINAL:
+ return date.fromordinal(o)
+ raise OverflowError("result out of range")
+ return NotImplemented
+
+ __radd__ = __add__
+
+ def __sub__(self, other):
+ """Subtract two dates, or a date and a timedelta."""
+ if isinstance(other, timedelta):
+ return self + timedelta(-other.days)
+ if isinstance(other, date):
+ days1 = self.toordinal()
+ days2 = other.toordinal()
+ return timedelta(days1 - days2)
+ return NotImplemented
+
+ def weekday(self):
+ "Return day of the week, where Monday == 0 ... Sunday == 6."
+ return (self.toordinal() + 6) % 7
+
+ # Day-of-the-week and week-of-the-year, according to ISO
+
+ def isoweekday(self):
+ "Return day of the week, where Monday == 1 ... Sunday == 7."
+ # 1-Jan-0001 is a Monday
+ return self.toordinal() % 7 or 7
+
+ def isocalendar(self):
+ """Return a 3-tuple containing ISO year, week number, and weekday.
+
+ The first ISO week of the year is the (Mon-Sun) week
+ containing the year's first Thursday; everything else derives
+ from that.
+
+ The first week is 1; Monday is 1 ... Sunday is 7.
+
+ ISO calendar algorithm taken from
+ http://www.phys.uu.nl/~vgent/calendar/isocalendar.htm
+ """
+ year = self._year
+ week1monday = _isoweek1monday(year)
+ today = _ymd2ord(self._year, self._month, self._day)
+ # Internally, week and day have origin 0
+ week, day = divmod(today - week1monday, 7)
+ if week < 0:
+ year -= 1
+ week1monday = _isoweek1monday(year)
+ week, day = divmod(today - week1monday, 7)
+ elif week >= 52:
+ if today >= _isoweek1monday(year+1):
+ year += 1
+ week = 0
+ return year, week+1, day+1
+
+ # Pickle support.
+
+ def _getstate(self):
+ yhi, ylo = divmod(self._year, 256)
+ return bytes([yhi, ylo, self._month, self._day]),
+
+ def __setstate(self, string):
+ if len(string) != 4 or not (1 <= string[2] <= 12):
+ raise TypeError("not enough arguments")
+ yhi, ylo, self._month, self._day = string
+ self._year = yhi * 256 + ylo
+
+ def __reduce__(self):
+ return (self.__class__, self._getstate())
+
+_date_class = date # so functions w/ args named "date" can get at the class
+
+date.min = date(1, 1, 1)
+date.max = date(9999, 12, 31)
+date.resolution = timedelta(days=1)
+
+class tzinfo:
+ """Abstract base class for time zone info classes.
+
+ Subclasses must override the name(), utcoffset() and dst() methods.
+ """
+ __slots__ = ()
+ def tzname(self, dt):
+ "datetime -> string name of time zone."
+ raise NotImplementedError("tzinfo subclass must override tzname()")
+
+ def utcoffset(self, dt):
+ "datetime -> minutes east of UTC (negative for west of UTC)"
+ raise NotImplementedError("tzinfo subclass must override utcoffset()")
+
+ def dst(self, dt):
+ """datetime -> DST offset in minutes east of UTC.
+
+ Return 0 if DST not in effect. utcoffset() must include the DST
+ offset.
+ """
+ raise NotImplementedError("tzinfo subclass must override dst()")
+
+ def fromutc(self, dt):
+ "datetime in UTC -> datetime in local time."
+
+ if not isinstance(dt, datetime):
+ raise TypeError("fromutc() requires a datetime argument")
+ if dt.tzinfo is not self:
+ raise ValueError("dt.tzinfo is not self")
+
+ dtoff = dt.utcoffset()
+ if dtoff is None:
+ raise ValueError("fromutc() requires a non-None utcoffset() "
+ "result")
+
+ # See the long comment block at the end of this file for an
+ # explanation of this algorithm.
+ dtdst = dt.dst()
+ if dtdst is None:
+ raise ValueError("fromutc() requires a non-None dst() result")
+ delta = dtoff - dtdst
+ if delta:
+ dt += delta
+ dtdst = dt.dst()
+ if dtdst is None:
+ raise ValueError("fromutc(): dt.dst gave inconsistent "
+ "results; cannot convert")
+ return dt + dtdst
+
+ # Pickle support.
+
+ def __reduce__(self):
+ getinitargs = getattr(self, "__getinitargs__", None)
+ if getinitargs:
+ args = getinitargs()
+ else:
+ args = ()
+ getstate = getattr(self, "__getstate__", None)
+ if getstate:
+ state = getstate()
+ else:
+ state = getattr(self, "__dict__", None) or None
+ if state is None:
+ return (self.__class__, args)
+ else:
+ return (self.__class__, args, state)
+
+_tzinfo_class = tzinfo
+
+class time:
+ """Time with time zone.
+
+ Constructors:
+
+ __new__()
+
+ Operators:
+
+ __repr__, __str__
+ __cmp__, __hash__
+
+ Methods:
+
+ strftime()
+ isoformat()
+ utcoffset()
+ tzname()
+ dst()
+
+ Properties (readonly):
+ hour, minute, second, microsecond, tzinfo
+ """
+
+ def __new__(cls, hour=0, minute=0, second=0, microsecond=0, tzinfo=None):
+ """Constructor.
+
+ Arguments:
+
+ hour, minute (required)
+ second, microsecond (default to zero)
+ tzinfo (default to None)
+ """
+ self = object.__new__(cls)
+ if isinstance(hour, bytes) and len(hour) == 6:
+ # Pickle support
+ self.__setstate(hour, minute or None)
+ return self
+ _check_tzinfo_arg(tzinfo)
+ _check_time_fields(hour, minute, second, microsecond)
+ self._hour = hour
+ self._minute = minute
+ self._second = second
+ self._microsecond = microsecond
+ self._tzinfo = tzinfo
+ return self
+
+ # Read-only field accessors
+ @property
+ def hour(self):
+ """hour (0-23)"""
+ return self._hour
+
+ @property
+ def minute(self):
+ """minute (0-59)"""
+ return self._minute
+
+ @property
+ def second(self):
+ """second (0-59)"""
+ return self._second
+
+ @property
+ def microsecond(self):
+ """microsecond (0-999999)"""
+ return self._microsecond
+
+ @property
+ def tzinfo(self):
+ """timezone info object"""
+ return self._tzinfo
+
+ # Standard conversions, __hash__ (and helpers)
+
+ # Comparisons of time objects with other.
+
+ def __eq__(self, other):
+ if isinstance(other, time):
+ return self._cmp(other, allow_mixed=True) == 0
+ else:
+ return False
+
+ def __ne__(self, other):
+ if isinstance(other, time):
+ return self._cmp(other, allow_mixed=True) != 0
+ else:
+ return True
+
+ def __le__(self, other):
+ if isinstance(other, time):
+ return self._cmp(other) <= 0
+ else:
+ _cmperror(self, other)
+
+ def __lt__(self, other):
+ if isinstance(other, time):
+ return self._cmp(other) < 0
+ else:
+ _cmperror(self, other)
+
+ def __ge__(self, other):
+ if isinstance(other, time):
+ return self._cmp(other) >= 0
+ else:
+ _cmperror(self, other)
+
+ def __gt__(self, other):
+ if isinstance(other, time):
+ return self._cmp(other) > 0
+ else:
+ _cmperror(self, other)
+
+ def _cmp(self, other, allow_mixed=False):
+ assert isinstance(other, time)
+ mytz = self._tzinfo
+ ottz = other._tzinfo
+ myoff = otoff = None
+
+ if mytz is ottz:
+ base_compare = True
+ else:
+ myoff = self.utcoffset()
+ otoff = other.utcoffset()
+ base_compare = myoff == otoff
+
+ if base_compare:
+ return _cmp((self._hour, self._minute, self._second,
+ self._microsecond),
+ (other._hour, other._minute, other._second,
+ other._microsecond))
+ if myoff is None or otoff is None:
+ if allow_mixed:
+ return 2 # arbitrary non-zero value
+ else:
+ raise TypeError("cannot compare naive and aware times")
+ myhhmm = self._hour * 60 + self._minute - myoff//timedelta(minutes=1)
+ othhmm = other._hour * 60 + other._minute - otoff//timedelta(minutes=1)
+ return _cmp((myhhmm, self._second, self._microsecond),
+ (othhmm, other._second, other._microsecond))
+
+ def __hash__(self):
+ """Hash."""
+ tzoff = self.utcoffset()
+ if not tzoff: # zero or None
+ return hash(self._getstate()[0])
+ h, m = divmod(timedelta(hours=self.hour, minutes=self.minute) - tzoff,
+ timedelta(hours=1))
+ assert not m % timedelta(minutes=1), "whole minute"
+ m //= timedelta(minutes=1)
+ if 0 <= h < 24:
+ return hash(time(h, m, self.second, self.microsecond))
+ return hash((h, m, self.second, self.microsecond))
+
+ # Conversion to string
+
+ def _tzstr(self, sep=":"):
+ """Return formatted timezone offset (+xx:xx) or None."""
+ off = self.utcoffset()
+ if off is not None:
+ if off.days < 0:
+ sign = "-"
+ off = -off
+ else:
+ sign = "+"
+ hh, mm = divmod(off, timedelta(hours=1))
+ assert not mm % timedelta(minutes=1), "whole minute"
+ mm //= timedelta(minutes=1)
+ assert 0 <= hh < 24
+ off = "%s%02d%s%02d" % (sign, hh, sep, mm)
+ return off
+
+ def __repr__(self):
+ """Convert to formal string, for repr()."""
+ if self._microsecond != 0:
+ s = ", %d, %d" % (self._second, self._microsecond)
+ elif self._second != 0:
+ s = ", %d" % self._second
+ else:
+ s = ""
+ s= "%s(%d, %d%s)" % ('datetime.' + self.__class__.__name__,
+ self._hour, self._minute, s)
+ if self._tzinfo is not None:
+ assert s[-1:] == ")"
+ s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
+ return s
+
+ def isoformat(self):
+ """Return the time formatted according to ISO.
+
+ This is 'HH:MM:SS.mmmmmm+zz:zz', or 'HH:MM:SS+zz:zz' if
+ self.microsecond == 0.
+ """
+ s = _format_time(self._hour, self._minute, self._second,
+ self._microsecond)
+ tz = self._tzstr()
+ if tz:
+ s += tz
+ return s
+
+ __str__ = isoformat
+
+ def strftime(self, fmt):
+ """Format using strftime(). The date part of the timestamp passed
+ to underlying strftime should not be used.
+ """
+ # The year must be >= 1000 else Python's strftime implementation
+ # can raise a bogus exception.
+ timetuple = (1900, 1, 1,
+ self._hour, self._minute, self._second,
+ 0, 1, -1)
+ return _wrap_strftime(self, fmt, timetuple)
+
+ def __format__(self, fmt):
+ if len(fmt) != 0:
+ return self.strftime(fmt)
+ return str(self)
+
+ # Timezone functions
+
+ def utcoffset(self):
+ """Return the timezone offset in minutes east of UTC (negative west of
+ UTC)."""
+ if self._tzinfo is None:
+ return None
+ offset = self._tzinfo.utcoffset(None)
+ _check_utc_offset("utcoffset", offset)
+ return offset
+
+ def tzname(self):
+ """Return the timezone name.
+
+ Note that the name is 100% informational -- there's no requirement that
+ it mean anything in particular. For example, "GMT", "UTC", "-500",
+ "-5:00", "EDT", "US/Eastern", "America/New York" are all valid replies.
+ """
+ if self._tzinfo is None:
+ return None
+ name = self._tzinfo.tzname(None)
+ _check_tzname(name)
+ return name
+
+ def dst(self):
+ """Return 0 if DST is not in effect, or the DST offset (in minutes
+ eastward) if DST is in effect.
+
+ This is purely informational; the DST offset has already been added to
+ the UTC offset returned by utcoffset() if applicable, so there's no
+ need to consult dst() unless you're interested in displaying the DST
+ info.
+ """
+ if self._tzinfo is None:
+ return None
+ offset = self._tzinfo.dst(None)
+ _check_utc_offset("dst", offset)
+ return offset
+
+ def replace(self, hour=None, minute=None, second=None, microsecond=None,
+ tzinfo=True):
+ """Return a new time with new values for the specified fields."""
+ if hour is None:
+ hour = self.hour
+ if minute is None:
+ minute = self.minute
+ if second is None:
+ second = self.second
+ if microsecond is None:
+ microsecond = self.microsecond
+ if tzinfo is True:
+ tzinfo = self.tzinfo
+ _check_time_fields(hour, minute, second, microsecond)
+ _check_tzinfo_arg(tzinfo)
+ return time(hour, minute, second, microsecond, tzinfo)
+
+ def __bool__(self):
+ if self.second or self.microsecond:
+ return True
+ offset = self.utcoffset() or timedelta(0)
+ return timedelta(hours=self.hour, minutes=self.minute) != offset
+
+ # Pickle support.
+
+ def _getstate(self):
+ us2, us3 = divmod(self._microsecond, 256)
+ us1, us2 = divmod(us2, 256)
+ basestate = bytes([self._hour, self._minute, self._second,
+ us1, us2, us3])
+ if self._tzinfo is None:
+ return (basestate,)
+ else:
+ return (basestate, self._tzinfo)
+
+ def __setstate(self, string, tzinfo):
+ if len(string) != 6 or string[0] >= 24:
+ raise TypeError("an integer is required")
+ (self._hour, self._minute, self._second,
+ us1, us2, us3) = string
+ self._microsecond = (((us1 << 8) | us2) << 8) | us3
+ if tzinfo is None or isinstance(tzinfo, _tzinfo_class):
+ self._tzinfo = tzinfo
+ else:
+ raise TypeError("bad tzinfo state arg %r" % tzinfo)
+
+ def __reduce__(self):
+ return (time, self._getstate())
+
+_time_class = time # so functions w/ args named "time" can get at the class
+
+time.min = time(0, 0, 0)
+time.max = time(23, 59, 59, 999999)
+time.resolution = timedelta(microseconds=1)
+
+class datetime(date):
+ """datetime(year, month, day[, hour[, minute[, second[, microsecond[,tzinfo]]]]])
+
+ The year, month and day arguments are required. tzinfo may be None, or an
+ instance of a tzinfo subclass. The remaining arguments may be ints.
+ """
+
+ __slots__ = date.__slots__ + (
+ '_hour', '_minute', '_second',
+ '_microsecond', '_tzinfo')
+ def __new__(cls, year, month=None, day=None, hour=0, minute=0, second=0,
+ microsecond=0, tzinfo=None):
+ if isinstance(year, bytes) and len(year) == 10:
+ # Pickle support
+ self = date.__new__(cls, year[:4])
+ self.__setstate(year, month)
+ return self
+ _check_tzinfo_arg(tzinfo)
+ _check_time_fields(hour, minute, second, microsecond)
+ self = date.__new__(cls, year, month, day)
+ self._hour = hour
+ self._minute = minute
+ self._second = second
+ self._microsecond = microsecond
+ self._tzinfo = tzinfo
+ return self
+
+ # Read-only field accessors
+ @property
+ def hour(self):
+ """hour (0-23)"""
+ return self._hour
+
+ @property
+ def minute(self):
+ """minute (0-59)"""
+ return self._minute
+
+ @property
+ def second(self):
+ """second (0-59)"""
+ return self._second
+
+ @property
+ def microsecond(self):
+ """microsecond (0-999999)"""
+ return self._microsecond
+
+ @property
+ def tzinfo(self):
+ """timezone info object"""
+ return self._tzinfo
+
+ @classmethod
+ def fromtimestamp(cls, t, tz=None):
+ """Construct a datetime from a POSIX timestamp (like time.time()).
+
+ A timezone info object may be passed in as well.
+ """
+
+ _check_tzinfo_arg(tz)
+
+ converter = _time.localtime if tz is None else _time.gmtime
+
+ t, frac = divmod(t, 1.0)
+ us = int(frac * 1e6)
+
+ # If timestamp is less than one microsecond smaller than a
+ # full second, us can be rounded up to 1000000. In this case,
+ # roll over to seconds, otherwise, ValueError is raised
+ # by the constructor.
+ if us == 1000000:
+ t += 1
+ us = 0
+ y, m, d, hh, mm, ss, weekday, jday, dst = converter(t)
+ ss = min(ss, 59) # clamp out leap seconds if the platform has them
+ result = cls(y, m, d, hh, mm, ss, us, tz)
+ if tz is not None:
+ result = tz.fromutc(result)
+ return result
+
+ @classmethod
+ def utcfromtimestamp(cls, t):
+ "Construct a UTC datetime from a POSIX timestamp (like time.time())."
+ t, frac = divmod(t, 1.0)
+ us = int(frac * 1e6)
+
+ # If timestamp is less than one microsecond smaller than a
+ # full second, us can be rounded up to 1000000. In this case,
+ # roll over to seconds, otherwise, ValueError is raised
+ # by the constructor.
+ if us == 1000000:
+ t += 1
+ us = 0
+ y, m, d, hh, mm, ss, weekday, jday, dst = _time.gmtime(t)
+ ss = min(ss, 59) # clamp out leap seconds if the platform has them
+ return cls(y, m, d, hh, mm, ss, us)
+
+ # XXX This is supposed to do better than we *can* do by using time.time(),
+ # XXX if the platform supports a more accurate way. The C implementation
+ # XXX uses gettimeofday on platforms that have it, but that isn't
+ # XXX available from Python. So now() may return different results
+ # XXX across the implementations.
+ @classmethod
+ def now(cls, tz=None):
+ "Construct a datetime from time.time() and optional time zone info."
+ t = _time.time()
+ return cls.fromtimestamp(t, tz)
+
+ @classmethod
+ def utcnow(cls):
+ "Construct a UTC datetime from time.time()."
+ t = _time.time()
+ return cls.utcfromtimestamp(t)
+
+ @classmethod
+ def combine(cls, date, time):
+ "Construct a datetime from a given date and a given time."
+ if not isinstance(date, _date_class):
+ raise TypeError("date argument must be a date instance")
+ if not isinstance(time, _time_class):
+ raise TypeError("time argument must be a time instance")
+ return cls(date.year, date.month, date.day,
+ time.hour, time.minute, time.second, time.microsecond,
+ time.tzinfo)
+
+ def timetuple(self):
+ "Return local time tuple compatible with time.localtime()."
+ dst = self.dst()
+ if dst is None:
+ dst = -1
+ elif dst:
+ dst = 1
+ else:
+ dst = 0
+ return _build_struct_time(self.year, self.month, self.day,
+ self.hour, self.minute, self.second,
+ dst)
+
+ def timestamp(self):
+ "Return POSIX timestamp as float"
+ if self._tzinfo is None:
+ return _time.mktime((self.year, self.month, self.day,
+ self.hour, self.minute, self.second,
+ -1, -1, -1)) + self.microsecond / 1e6
+ else:
+ return (self - _EPOCH).total_seconds()
+
+ def utctimetuple(self):
+ "Return UTC time tuple compatible with time.gmtime()."
+ offset = self.utcoffset()
+ if offset:
+ self -= offset
+ y, m, d = self.year, self.month, self.day
+ hh, mm, ss = self.hour, self.minute, self.second
+ return _build_struct_time(y, m, d, hh, mm, ss, 0)
+
+ def date(self):
+ "Return the date part."
+ return date(self._year, self._month, self._day)
+
+ def time(self):
+ "Return the time part, with tzinfo None."
+ return time(self.hour, self.minute, self.second, self.microsecond)
+
+ def timetz(self):
+ "Return the time part, with same tzinfo."
+ return time(self.hour, self.minute, self.second, self.microsecond,
+ self._tzinfo)
+
+ def replace(self, year=None, month=None, day=None, hour=None,
+ minute=None, second=None, microsecond=None, tzinfo=True):
+ """Return a new datetime with new values for the specified fields."""
+ if year is None:
+ year = self.year
+ if month is None:
+ month = self.month
+ if day is None:
+ day = self.day
+ if hour is None:
+ hour = self.hour
+ if minute is None:
+ minute = self.minute
+ if second is None:
+ second = self.second
+ if microsecond is None:
+ microsecond = self.microsecond
+ if tzinfo is True:
+ tzinfo = self.tzinfo
+ _check_date_fields(year, month, day)
+ _check_time_fields(hour, minute, second, microsecond)
+ _check_tzinfo_arg(tzinfo)
+ return datetime(year, month, day, hour, minute, second,
+ microsecond, tzinfo)
+
+ def astimezone(self, tz=None):
+ if tz is None:
+ if self.tzinfo is None:
+ raise ValueError("astimezone() requires an aware datetime")
+ ts = (self - _EPOCH) // timedelta(seconds=1)
+ localtm = _time.localtime(ts)
+ local = datetime(*localtm[:6])
+ try:
+ # Extract TZ data if available
+ gmtoff = localtm.tm_gmtoff
+ zone = localtm.tm_zone
+ except AttributeError:
+ # Compute UTC offset and compare with the value implied
+ # by tm_isdst. If the values match, use the zone name
+ # implied by tm_isdst.
+ delta = local - datetime(*_time.gmtime(ts)[:6])
+ dst = _time.daylight and localtm.tm_isdst > 0
+ gmtoff = -(_time.altzone if dst else _time.timezone)
+ if delta == timedelta(seconds=gmtoff):
+ tz = timezone(delta, _time.tzname[dst])
+ else:
+ tz = timezone(delta)
+ else:
+ tz = timezone(timedelta(seconds=gmtoff), zone)
+
+ elif not isinstance(tz, tzinfo):
+ raise TypeError("tz argument must be an instance of tzinfo")
+
+ mytz = self.tzinfo
+ if mytz is None:
+ raise ValueError("astimezone() requires an aware datetime")
+
+ if tz is mytz:
+ return self
+
+ # Convert self to UTC, and attach the new time zone object.
+ myoffset = self.utcoffset()
+ if myoffset is None:
+ raise ValueError("astimezone() requires an aware datetime")
+ utc = (self - myoffset).replace(tzinfo=tz)
+
+ # Convert from UTC to tz's local time.
+ return tz.fromutc(utc)
+
+ # Ways to produce a string.
+
+ def ctime(self):
+ "Return ctime() style string."
+ weekday = self.toordinal() % 7 or 7
+ return "%s %s %2d %02d:%02d:%02d %04d" % (
+ _DAYNAMES[weekday],
+ _MONTHNAMES[self._month],
+ self._day,
+ self._hour, self._minute, self._second,
+ self._year)
+
+ def isoformat(self, sep='T'):
+ """Return the time formatted according to ISO.
+
+ This is 'YYYY-MM-DD HH:MM:SS.mmmmmm', or 'YYYY-MM-DD HH:MM:SS' if
+ self.microsecond == 0.
+
+ If self.tzinfo is not None, the UTC offset is also attached, giving
+ 'YYYY-MM-DD HH:MM:SS.mmmmmm+HH:MM' or 'YYYY-MM-DD HH:MM:SS+HH:MM'.
+
+ Optional argument sep specifies the separator between date and
+ time, default 'T'.
+ """
+ s = ("%04d-%02d-%02d%c" % (self._year, self._month, self._day,
+ sep) +
+ _format_time(self._hour, self._minute, self._second,
+ self._microsecond))
+ off = self.utcoffset()
+ if off is not None:
+ if off.days < 0:
+ sign = "-"
+ off = -off
+ else:
+ sign = "+"
+ hh, mm = divmod(off, timedelta(hours=1))
+ assert not mm % timedelta(minutes=1), "whole minute"
+ mm //= timedelta(minutes=1)
+ s += "%s%02d:%02d" % (sign, hh, mm)
+ return s
+
+ def __repr__(self):
+ """Convert to formal string, for repr()."""
+ L = [self._year, self._month, self._day, # These are never zero
+ self._hour, self._minute, self._second, self._microsecond]
+ if L[-1] == 0:
+ del L[-1]
+ if L[-1] == 0:
+ del L[-1]
+ s = ", ".join(map(str, L))
+ s = "%s(%s)" % ('datetime.' + self.__class__.__name__, s)
+ if self._tzinfo is not None:
+ assert s[-1:] == ")"
+ s = s[:-1] + ", tzinfo=%r" % self._tzinfo + ")"
+ return s
+
+ def __str__(self):
+ "Convert to string, for str()."
+ return self.isoformat(sep=' ')
+
+ @classmethod
+ def strptime(cls, date_string, format):
+ 'string, format -> new datetime parsed from a string (like time.strptime()).'
+ import _strptime
+ return _strptime._strptime_datetime(cls, date_string, format)
+
+ def utcoffset(self):
+ """Return the timezone offset in minutes east of UTC (negative west of
+ UTC)."""
+ if self._tzinfo is None:
+ return None
+ offset = self._tzinfo.utcoffset(self)
+ _check_utc_offset("utcoffset", offset)
+ return offset
+
+ def tzname(self):
+ """Return the timezone name.
+
+ Note that the name is 100% informational -- there's no requirement that
+ it mean anything in particular. For example, "GMT", "UTC", "-500",
+ "-5:00", "EDT", "US/Eastern", "America/New York" are all valid replies.
+ """
+ name = _call_tzinfo_method(self._tzinfo, "tzname", self)
+ _check_tzname(name)
+ return name
+
+ def dst(self):
+ """Return 0 if DST is not in effect, or the DST offset (in minutes
+ eastward) if DST is in effect.
+
+ This is purely informational; the DST offset has already been added to
+ the UTC offset returned by utcoffset() if applicable, so there's no
+ need to consult dst() unless you're interested in displaying the DST
+ info.
+ """
+ if self._tzinfo is None:
+ return None
+ offset = self._tzinfo.dst(self)
+ _check_utc_offset("dst", offset)
+ return offset
+
+ # Comparisons of datetime objects with other.
+
+ def __eq__(self, other):
+ if isinstance(other, datetime):
+ return self._cmp(other, allow_mixed=True) == 0
+ elif not isinstance(other, date):
+ return NotImplemented
+ else:
+ return False
+
+ def __ne__(self, other):
+ if isinstance(other, datetime):
+ return self._cmp(other, allow_mixed=True) != 0
+ elif not isinstance(other, date):
+ return NotImplemented
+ else:
+ return True
+
+ def __le__(self, other):
+ if isinstance(other, datetime):
+ return self._cmp(other) <= 0
+ elif not isinstance(other, date):
+ return NotImplemented
+ else:
+ _cmperror(self, other)
+
+ def __lt__(self, other):
+ if isinstance(other, datetime):
+ return self._cmp(other) < 0
+ elif not isinstance(other, date):
+ return NotImplemented
+ else:
+ _cmperror(self, other)
+
+ def __ge__(self, other):
+ if isinstance(other, datetime):
+ return self._cmp(other) >= 0
+ elif not isinstance(other, date):
+ return NotImplemented
+ else:
+ _cmperror(self, other)
+
+ def __gt__(self, other):
+ if isinstance(other, datetime):
+ return self._cmp(other) > 0
+ elif not isinstance(other, date):
+ return NotImplemented
+ else:
+ _cmperror(self, other)
+
+ def _cmp(self, other, allow_mixed=False):
+ assert isinstance(other, datetime)
+ mytz = self._tzinfo
+ ottz = other._tzinfo
+ myoff = otoff = None
+
+ if mytz is ottz:
+ base_compare = True
+ else:
+ myoff = self.utcoffset()
+ otoff = other.utcoffset()
+ base_compare = myoff == otoff
+
+ if base_compare:
+ return _cmp((self._year, self._month, self._day,
+ self._hour, self._minute, self._second,
+ self._microsecond),
+ (other._year, other._month, other._day,
+ other._hour, other._minute, other._second,
+ other._microsecond))
+ if myoff is None or otoff is None:
+ if allow_mixed:
+ return 2 # arbitrary non-zero value
+ else:
+ raise TypeError("cannot compare naive and aware datetimes")
+ # XXX What follows could be done more efficiently...
+ diff = self - other # this will take offsets into account
+ if diff.days < 0:
+ return -1
+ return diff and 1 or 0
+
+ def __add__(self, other):
+ "Add a datetime and a timedelta."
+ if not isinstance(other, timedelta):
+ return NotImplemented
+ delta = timedelta(self.toordinal(),
+ hours=self._hour,
+ minutes=self._minute,
+ seconds=self._second,
+ microseconds=self._microsecond)
+ delta += other
+ hour, rem = divmod(delta.seconds, 3600)
+ minute, second = divmod(rem, 60)
+ if 0 < delta.days <= _MAXORDINAL:
+ return datetime.combine(date.fromordinal(delta.days),
+ time(hour, minute, second,
+ delta.microseconds,
+ tzinfo=self._tzinfo))
+ raise OverflowError("result out of range")
+
+ __radd__ = __add__
+
+ def __sub__(self, other):
+ "Subtract two datetimes, or a datetime and a timedelta."
+ if not isinstance(other, datetime):
+ if isinstance(other, timedelta):
+ return self + -other
+ return NotImplemented
+
+ days1 = self.toordinal()
+ days2 = other.toordinal()
+ secs1 = self._second + self._minute * 60 + self._hour * 3600
+ secs2 = other._second + other._minute * 60 + other._hour * 3600
+ base = timedelta(days1 - days2,
+ secs1 - secs2,
+ self._microsecond - other._microsecond)
+ if self._tzinfo is other._tzinfo:
+ return base
+ myoff = self.utcoffset()
+ otoff = other.utcoffset()
+ if myoff == otoff:
+ return base
+ if myoff is None or otoff is None:
+ raise TypeError("cannot mix naive and timezone-aware time")
+ return base + otoff - myoff
+
+ def __hash__(self):
+ tzoff = self.utcoffset()
+ if tzoff is None:
+ return hash(self._getstate()[0])
+ days = _ymd2ord(self.year, self.month, self.day)
+ seconds = self.hour * 3600 + self.minute * 60 + self.second
+ return hash(timedelta(days, seconds, self.microsecond) - tzoff)
+
+ # Pickle support.
+
+ def _getstate(self):
+ yhi, ylo = divmod(self._year, 256)
+ us2, us3 = divmod(self._microsecond, 256)
+ us1, us2 = divmod(us2, 256)
+ basestate = bytes([yhi, ylo, self._month, self._day,
+ self._hour, self._minute, self._second,
+ us1, us2, us3])
+ if self._tzinfo is None:
+ return (basestate,)
+ else:
+ return (basestate, self._tzinfo)
+
+ def __setstate(self, string, tzinfo):
+ (yhi, ylo, self._month, self._day, self._hour,
+ self._minute, self._second, us1, us2, us3) = string
+ self._year = yhi * 256 + ylo
+ self._microsecond = (((us1 << 8) | us2) << 8) | us3
+ if tzinfo is None or isinstance(tzinfo, _tzinfo_class):
+ self._tzinfo = tzinfo
+ else:
+ raise TypeError("bad tzinfo state arg %r" % tzinfo)
+
+ def __reduce__(self):
+ return (self.__class__, self._getstate())
+
+
+datetime.min = datetime(1, 1, 1)
+datetime.max = datetime(9999, 12, 31, 23, 59, 59, 999999)
+datetime.resolution = timedelta(microseconds=1)
+
+
+def _isoweek1monday(year):
+ # Helper to calculate the day number of the Monday starting week 1
+ # XXX This could be done more efficiently
+ THURSDAY = 3
+ firstday = _ymd2ord(year, 1, 1)
+ firstweekday = (firstday + 6) % 7 # See weekday() above
+ week1monday = firstday - firstweekday
+ if firstweekday > THURSDAY:
+ week1monday += 7
+ return week1monday
+
+class timezone(tzinfo):
+ __slots__ = '_offset', '_name'
+
+ # Sentinel value to disallow None
+ _Omitted = object()
+ def __new__(cls, offset, name=_Omitted):
+ if not isinstance(offset, timedelta):
+ raise TypeError("offset must be a timedelta")
+ if name is cls._Omitted:
+ if not offset:
+ return cls.utc
+ name = None
+ elif not isinstance(name, str):
+ raise TypeError("name must be a string")
+ if not cls._minoffset <= offset <= cls._maxoffset:
+ raise ValueError("offset must be a timedelta"
+ " strictly between -timedelta(hours=24) and"
+ " timedelta(hours=24).")
+ if (offset.microseconds != 0 or
+ offset.seconds % 60 != 0):
+ raise ValueError("offset must be a timedelta"
+ " representing a whole number of minutes")
+ return cls._create(offset, name)
+
+ @classmethod
+ def _create(cls, offset, name=None):
+ self = tzinfo.__new__(cls)
+ self._offset = offset
+ self._name = name
+ return self
+
+ def __getinitargs__(self):
+ """pickle support"""
+ if self._name is None:
+ return (self._offset,)
+ return (self._offset, self._name)
+
+ def __eq__(self, other):
+ if type(other) != timezone:
+ return False
+ return self._offset == other._offset
+
+ def __hash__(self):
+ return hash(self._offset)
+
+ def __repr__(self):
+ """Convert to formal string, for repr().
+
+ >>> tz = timezone.utc
+ >>> repr(tz)
+ 'datetime.timezone.utc'
+ >>> tz = timezone(timedelta(hours=-5), 'EST')
+ >>> repr(tz)
+ "datetime.timezone(datetime.timedelta(-1, 68400), 'EST')"
+ """
+ if self is self.utc:
+ return 'datetime.timezone.utc'
+ if self._name is None:
+ return "%s(%r)" % ('datetime.' + self.__class__.__name__,
+ self._offset)
+ return "%s(%r, %r)" % ('datetime.' + self.__class__.__name__,
+ self._offset, self._name)
+
+ def __str__(self):
+ return self.tzname(None)
+
+ def utcoffset(self, dt):
+ if isinstance(dt, datetime) or dt is None:
+ return self._offset
+ raise TypeError("utcoffset() argument must be a datetime instance"
+ " or None")
+
+ def tzname(self, dt):
+ if isinstance(dt, datetime) or dt is None:
+ if self._name is None:
+ return self._name_from_offset(self._offset)
+ return self._name
+ raise TypeError("tzname() argument must be a datetime instance"
+ " or None")
+
+ def dst(self, dt):
+ if isinstance(dt, datetime) or dt is None:
+ return None
+ raise TypeError("dst() argument must be a datetime instance"
+ " or None")
+
+ def fromutc(self, dt):
+ if isinstance(dt, datetime):
+ if dt.tzinfo is not self:
+ raise ValueError("fromutc: dt.tzinfo "
+ "is not self")
+ return dt + self._offset
+ raise TypeError("fromutc() argument must be a datetime instance"
+ " or None")
+
+ _maxoffset = timedelta(hours=23, minutes=59)
+ _minoffset = -_maxoffset
+
+ @staticmethod
+ def _name_from_offset(delta):
+ if delta < timedelta(0):
+ sign = '-'
+ delta = -delta
+ else:
+ sign = '+'
+ hours, rest = divmod(delta, timedelta(hours=1))
+ minutes = rest // timedelta(minutes=1)
+ return 'UTC{}{:02d}:{:02d}'.format(sign, hours, minutes)
+
+timezone.utc = timezone._create(timedelta(0))
+timezone.min = timezone._create(timezone._minoffset)
+timezone.max = timezone._create(timezone._maxoffset)
+_EPOCH = datetime(1970, 1, 1, tzinfo=timezone.utc)
+
+# Some time zone algebra. For a datetime x, let
+# x.n = x stripped of its timezone -- its naive time.
+# x.o = x.utcoffset(), and assuming that doesn't raise an exception or
+# return None
+# x.d = x.dst(), and assuming that doesn't raise an exception or
+# return None
+# x.s = x's standard offset, x.o - x.d
+#
+# Now some derived rules, where k is a duration (timedelta).
+#
+# 1. x.o = x.s + x.d
+# This follows from the definition of x.s.
+#
+# 2. If x and y have the same tzinfo member, x.s = y.s.
+# This is actually a requirement, an assumption we need to make about
+# sane tzinfo classes.
+#
+# 3. The naive UTC time corresponding to x is x.n - x.o.
+# This is again a requirement for a sane tzinfo class.
+#
+# 4. (x+k).s = x.s
+# This follows from #2, and that datimetimetz+timedelta preserves tzinfo.
+#
+# 5. (x+k).n = x.n + k
+# Again follows from how arithmetic is defined.
+#
+# Now we can explain tz.fromutc(x). Let's assume it's an interesting case
+# (meaning that the various tzinfo methods exist, and don't blow up or return
+# None when called).
+#
+# The function wants to return a datetime y with timezone tz, equivalent to x.
+# x is already in UTC.
+#
+# By #3, we want
+#
+# y.n - y.o = x.n [1]
+#
+# The algorithm starts by attaching tz to x.n, and calling that y. So
+# x.n = y.n at the start. Then it wants to add a duration k to y, so that [1]
+# becomes true; in effect, we want to solve [2] for k:
+#
+# (y+k).n - (y+k).o = x.n [2]
+#
+# By #1, this is the same as
+#
+# (y+k).n - ((y+k).s + (y+k).d) = x.n [3]
+#
+# By #5, (y+k).n = y.n + k, which equals x.n + k because x.n=y.n at the start.
+# Substituting that into [3],
+#
+# x.n + k - (y+k).s - (y+k).d = x.n; the x.n terms cancel, leaving
+# k - (y+k).s - (y+k).d = 0; rearranging,
+# k = (y+k).s - (y+k).d; by #4, (y+k).s == y.s, so
+# k = y.s - (y+k).d
+#
+# On the RHS, (y+k).d can't be computed directly, but y.s can be, and we
+# approximate k by ignoring the (y+k).d term at first. Note that k can't be
+# very large, since all offset-returning methods return a duration of magnitude
+# less than 24 hours. For that reason, if y is firmly in std time, (y+k).d must
+# be 0, so ignoring it has no consequence then.
+#
+# In any case, the new value is
+#
+# z = y + y.s [4]
+#
+# It's helpful to step back at look at [4] from a higher level: it's simply
+# mapping from UTC to tz's standard time.
+#
+# At this point, if
+#
+# z.n - z.o = x.n [5]
+#
+# we have an equivalent time, and are almost done. The insecurity here is
+# at the start of daylight time. Picture US Eastern for concreteness. The wall
+# time jumps from 1:59 to 3:00, and wall hours of the form 2:MM don't make good
+# sense then. The docs ask that an Eastern tzinfo class consider such a time to
+# be EDT (because it's "after 2"), which is a redundant spelling of 1:MM EST
+# on the day DST starts. We want to return the 1:MM EST spelling because that's
+# the only spelling that makes sense on the local wall clock.
+#
+# In fact, if [5] holds at this point, we do have the standard-time spelling,
+# but that takes a bit of proof. We first prove a stronger result. What's the
+# difference between the LHS and RHS of [5]? Let
+#
+# diff = x.n - (z.n - z.o) [6]
+#
+# Now
+# z.n = by [4]
+# (y + y.s).n = by #5
+# y.n + y.s = since y.n = x.n
+# x.n + y.s = since z and y are have the same tzinfo member,
+# y.s = z.s by #2
+# x.n + z.s
+#
+# Plugging that back into [6] gives
+#
+# diff =
+# x.n - ((x.n + z.s) - z.o) = expanding
+# x.n - x.n - z.s + z.o = cancelling
+# - z.s + z.o = by #2
+# z.d
+#
+# So diff = z.d.
+#
+# If [5] is true now, diff = 0, so z.d = 0 too, and we have the standard-time
+# spelling we wanted in the endcase described above. We're done. Contrarily,
+# if z.d = 0, then we have a UTC equivalent, and are also done.
+#
+# If [5] is not true now, diff = z.d != 0, and z.d is the offset we need to
+# add to z (in effect, z is in tz's standard time, and we need to shift the
+# local clock into tz's daylight time).
+#
+# Let
+#
+# z' = z + z.d = z + diff [7]
+#
+# and we can again ask whether
+#
+# z'.n - z'.o = x.n [8]
+#
+# If so, we're done. If not, the tzinfo class is insane, according to the
+# assumptions we've made. This also requires a bit of proof. As before, let's
+# compute the difference between the LHS and RHS of [8] (and skipping some of
+# the justifications for the kinds of substitutions we've done several times
+# already):
+#
+# diff' = x.n - (z'.n - z'.o) = replacing z'.n via [7]
+# x.n - (z.n + diff - z'.o) = replacing diff via [6]
+# x.n - (z.n + x.n - (z.n - z.o) - z'.o) =
+# x.n - z.n - x.n + z.n - z.o + z'.o = cancel x.n
+# - z.n + z.n - z.o + z'.o = cancel z.n
+# - z.o + z'.o = #1 twice
+# -z.s - z.d + z'.s + z'.d = z and z' have same tzinfo
+# z'.d - z.d
+#
+# So z' is UTC-equivalent to x iff z'.d = z.d at this point. If they are equal,
+# we've found the UTC-equivalent so are done. In fact, we stop with [7] and
+# return z', not bothering to compute z'.d.
+#
+# How could z.d and z'd differ? z' = z + z.d [7], so merely moving z' by
+# a dst() offset, and starting *from* a time already in DST (we know z.d != 0),
+# would have to change the result dst() returns: we start in DST, and moving
+# a little further into it takes us out of DST.
+#
+# There isn't a sane case where this can happen. The closest it gets is at
+# the end of DST, where there's an hour in UTC with no spelling in a hybrid
+# tzinfo class. In US Eastern, that's 5:MM UTC = 0:MM EST = 1:MM EDT. During
+# that hour, on an Eastern clock 1:MM is taken as being in standard time (6:MM
+# UTC) because the docs insist on that, but 0:MM is taken as being in daylight
+# time (4:MM UTC). There is no local time mapping to 5:MM UTC. The local
+# clock jumps from 1:59 back to 1:00 again, and repeats the 1:MM hour in
+# standard time. Since that's what the local clock *does*, we want to map both
+# UTC hours 5:MM and 6:MM to 1:MM Eastern. The result is ambiguous
+# in local time, but so it goes -- it's the way the local clock works.
+#
+# When x = 5:MM UTC is the input to this algorithm, x.o=0, y.o=-5 and y.d=0,
+# so z=0:MM. z.d=60 (minutes) then, so [5] doesn't hold and we keep going.
+# z' = z + z.d = 1:MM then, and z'.d=0, and z'.d - z.d = -60 != 0 so [8]
+# (correctly) concludes that z' is not UTC-equivalent to x.
+#
+# Because we know z.d said z was in daylight time (else [5] would have held and
+# we would have stopped then), and we know z.d != z'.d (else [8] would have held
+# and we have stopped then), and there are only 2 possible values dst() can
+# return in Eastern, it follows that z'.d must be 0 (which it is in the example,
+# but the reasoning doesn't depend on the example -- it depends on there being
+# two possible dst() outcomes, one zero and the other non-zero). Therefore
+# z' must be in standard time, and is the spelling we want in this case.
+#
+# Note again that z' is not UTC-equivalent as far as the hybrid tzinfo class is
+# concerned (because it takes z' as being in standard time rather than the
+# daylight time we intend here), but returning it gives the real-life "local
+# clock repeats an hour" behavior when mapping the "unspellable" UTC hour into
+# tz.
+#
+# When the input is 6:MM, z=1:MM and z.d=0, and we stop at once, again with
+# the 1:MM standard time spelling we want.
+#
+# So how can this break? One of the assumptions must be violated. Two
+# possibilities:
+#
+# 1) [2] effectively says that y.s is invariant across all y belong to a given
+# time zone. This isn't true if, for political reasons or continental drift,
+# a region decides to change its base offset from UTC.
+#
+# 2) There may be versions of "double daylight" time where the tail end of
+# the analysis gives up a step too early. I haven't thought about that
+# enough to say.
+#
+# In any case, it's clear that the default fromutc() is strong enough to handle
+# "almost all" time zones: so long as the standard offset is invariant, it
+# doesn't matter if daylight time transition points change from year to year, or
+# if daylight time is skipped in some years; it doesn't matter how large or
+# small dst() may get within its bounds; and it doesn't even matter if some
+# perverse time zone returns a negative dst()). So a breaking case must be
+# pretty bizarre, and a tzinfo subclass can override fromutc() if it is.
+
+try:
+ from _datetime import *
+except ImportError:
+ pass
+else:
+ # Clean up unused names
+ del (_DAYNAMES, _DAYS_BEFORE_MONTH, _DAYS_IN_MONTH,
+ _DI100Y, _DI400Y, _DI4Y, _MAXORDINAL, _MONTHNAMES,
+ _build_struct_time, _call_tzinfo_method, _check_date_fields,
+ _check_time_fields, _check_tzinfo_arg, _check_tzname,
+ _check_utc_offset, _cmp, _cmperror, _date_class, _days_before_month,
+ _days_before_year, _days_in_month, _format_time, _is_leap,
+ _isoweek1monday, _math, _ord2ymd, _time, _time_class, _tzinfo_class,
+ _wrap_strftime, _ymd2ord)
+ # XXX Since import * above excludes names that start with _,
+ # docstring does not get overwritten. In the future, it may be
+ # appropriate to maintain a single module level docstring and
+ # remove the following line.
+ from _datetime import __doc__
--- /dev/null
+"""The io module provides the Python interfaces to stream handling. The
+builtin open function is defined in this module.
+
+At the top of the I/O hierarchy is the abstract base class IOBase. It
+defines the basic interface to a stream. Note, however, that there is no
+separation between reading and writing to streams; implementations are
+allowed to raise an OSError if they do not support a given operation.
+
+Extending IOBase is RawIOBase which deals simply with the reading and
+writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide
+an interface to OS files.
+
+BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its
+subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer
+streams that are readable, writable, and both respectively.
+BufferedRandom provides a buffered interface to random access
+streams. BytesIO is a simple stream of in-memory bytes.
+
+Another IOBase subclass, TextIOBase, deals with the encoding and decoding
+of streams into text. TextIOWrapper, which extends it, is a buffered text
+interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO
+is a in-memory stream for text.
+
+Argument names are not part of the specification, and only the arguments
+of open() are intended to be used as keyword arguments.
+
+data:
+
+DEFAULT_BUFFER_SIZE
+
+ An int containing the default buffer size used by the module's buffered
+ I/O classes. open() uses the file's blksize (as obtained by os.stat) if
+ possible.
+"""
+# New I/O library conforming to PEP 3116.
+
+__author__ = ("Guido van Rossum <guido@python.org>, "
+ "Mike Verdone <mike.verdone@gmail.com>, "
+ "Mark Russell <mark.russell@zen.co.uk>, "
+ "Antoine Pitrou <solipsis@pitrou.net>, "
+ "Amaury Forgeot d'Arc <amauryfa@gmail.com>, "
+ "Benjamin Peterson <benjamin@python.org>")
+
+__all__ = ["BlockingIOError", "open", "IOBase", "RawIOBase", "FileIO",
+ "BytesIO", "StringIO", "BufferedIOBase",
+ "BufferedReader", "BufferedWriter", "BufferedRWPair",
+ "BufferedRandom", "TextIOBase", "TextIOWrapper",
+ "UnsupportedOperation", "SEEK_SET", "SEEK_CUR", "SEEK_END"]
+
+
+import _io
+import abc
+
+from _io import (DEFAULT_BUFFER_SIZE, BlockingIOError, UnsupportedOperation,
+ open, FileIO, BytesIO, StringIO, BufferedReader,
+ BufferedWriter, BufferedRWPair, BufferedRandom,
+ IncrementalNewlineDecoder, TextIOWrapper)
+
+OpenWrapper = _io.open # for compatibility with _pyio
+
+# Pretend this exception was created here.
+UnsupportedOperation.__module__ = "io"
+
+# for seek()
+SEEK_SET = 0
+SEEK_CUR = 1
+SEEK_END = 2
+
+# Declaring ABCs in C is tricky so we do it here.
+# Method descriptions and default implementations are inherited from the C
+# version however.
+class IOBase(_io._IOBase, metaclass=abc.ABCMeta):
+ __doc__ = _io._IOBase.__doc__
+
+class RawIOBase(_io._RawIOBase, IOBase):
+ __doc__ = _io._RawIOBase.__doc__
+
+class BufferedIOBase(_io._BufferedIOBase, IOBase):
+ __doc__ = _io._BufferedIOBase.__doc__
+
+class TextIOBase(_io._TextIOBase, IOBase):
+ __doc__ = _io._TextIOBase.__doc__
+
+RawIOBase.register(FileIO)
+
+for klass in (BytesIO, BufferedReader, BufferedWriter, BufferedRandom,
+ BufferedRWPair):
+ BufferedIOBase.register(klass)
+
+for klass in (StringIO, TextIOWrapper):
+ TextIOBase.register(klass)
+del klass
--- /dev/null
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Abstract Base Classes (ABCs) for numbers, according to PEP 3141.
+
+TODO: Fill out more detailed documentation on the operators."""
+
+from abc import ABCMeta, abstractmethod
+
+__all__ = ["Number", "Complex", "Real", "Rational", "Integral"]
+
+class Number(metaclass=ABCMeta):
+ """All numbers inherit from this class.
+
+ If you just want to check if an argument x is a number, without
+ caring what kind, use isinstance(x, Number).
+ """
+ __slots__ = ()
+
+ # Concrete numeric types must provide their own hash implementation
+ __hash__ = None
+
+
+## Notes on Decimal
+## ----------------
+## Decimal has all of the methods specified by the Real abc, but it should
+## not be registered as a Real because decimals do not interoperate with
+## binary floats (i.e. Decimal('3.14') + 2.71828 is undefined). But,
+## abstract reals are expected to interoperate (i.e. R1 + R2 should be
+## expected to work if R1 and R2 are both Reals).
+
+class Complex(Number):
+ """Complex defines the operations that work on the builtin complex type.
+
+ In short, those are: a conversion to complex, .real, .imag, +, -,
+ *, /, abs(), .conjugate, ==, and !=.
+
+ If it is given heterogenous arguments, and doesn't have special
+ knowledge about them, it should fall back to the builtin complex
+ type as described below.
+ """
+
+ __slots__ = ()
+
+ @abstractmethod
+ def __complex__(self):
+ """Return a builtin complex instance. Called for complex(self)."""
+
+ def __bool__(self):
+ """True if self != 0. Called for bool(self)."""
+ return self != 0
+
+ @property
+ @abstractmethod
+ def real(self):
+ """Retrieve the real component of this number.
+
+ This should subclass Real.
+ """
+ raise NotImplementedError
+
+ @property
+ @abstractmethod
+ def imag(self):
+ """Retrieve the imaginary component of this number.
+
+ This should subclass Real.
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def __add__(self, other):
+ """self + other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __radd__(self, other):
+ """other + self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __neg__(self):
+ """-self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __pos__(self):
+ """+self"""
+ raise NotImplementedError
+
+ def __sub__(self, other):
+ """self - other"""
+ return self + -other
+
+ def __rsub__(self, other):
+ """other - self"""
+ return -self + other
+
+ @abstractmethod
+ def __mul__(self, other):
+ """self * other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rmul__(self, other):
+ """other * self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __truediv__(self, other):
+ """self / other: Should promote to float when necessary."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rtruediv__(self, other):
+ """other / self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __pow__(self, exponent):
+ """self**exponent; should promote to float or complex when necessary."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rpow__(self, base):
+ """base ** self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __abs__(self):
+ """Returns the Real distance from 0. Called for abs(self)."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def conjugate(self):
+ """(x+y*i).conjugate() returns (x-y*i)."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __eq__(self, other):
+ """self == other"""
+ raise NotImplementedError
+
+ def __ne__(self, other):
+ """self != other"""
+ # The default __ne__ doesn't negate __eq__ until 3.0.
+ return not (self == other)
+
+Complex.register(complex)
+
+
+class Real(Complex):
+ """To Complex, Real adds the operations that work on real numbers.
+
+ In short, those are: a conversion to float, trunc(), divmod,
+ %, <, <=, >, and >=.
+
+ Real also provides defaults for the derived operations.
+ """
+
+ __slots__ = ()
+
+ @abstractmethod
+ def __float__(self):
+ """Any Real can be converted to a native float object.
+
+ Called for float(self)."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __trunc__(self):
+ """trunc(self): Truncates self to an Integral.
+
+ Returns an Integral i such that:
+ * i>0 iff self>0;
+ * abs(i) <= abs(self);
+ * for any Integral j satisfying the first two conditions,
+ abs(i) >= abs(j) [i.e. i has "maximal" abs among those].
+ i.e. "truncate towards 0".
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def __floor__(self):
+ """Finds the greatest Integral <= self."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __ceil__(self):
+ """Finds the least Integral >= self."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __round__(self, ndigits=None):
+ """Rounds self to ndigits decimal places, defaulting to 0.
+
+ If ndigits is omitted or None, returns an Integral, otherwise
+ returns a Real. Rounds half toward even.
+ """
+ raise NotImplementedError
+
+ def __divmod__(self, other):
+ """divmod(self, other): The pair (self // other, self % other).
+
+ Sometimes this can be computed faster than the pair of
+ operations.
+ """
+ return (self // other, self % other)
+
+ def __rdivmod__(self, other):
+ """divmod(other, self): The pair (self // other, self % other).
+
+ Sometimes this can be computed faster than the pair of
+ operations.
+ """
+ return (other // self, other % self)
+
+ @abstractmethod
+ def __floordiv__(self, other):
+ """self // other: The floor() of self/other."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rfloordiv__(self, other):
+ """other // self: The floor() of other/self."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __mod__(self, other):
+ """self % other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rmod__(self, other):
+ """other % self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __lt__(self, other):
+ """self < other
+
+ < on Reals defines a total ordering, except perhaps for NaN."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __le__(self, other):
+ """self <= other"""
+ raise NotImplementedError
+
+ # Concrete implementations of Complex abstract methods.
+ def __complex__(self):
+ """complex(self) == complex(float(self), 0)"""
+ return complex(float(self))
+
+ @property
+ def real(self):
+ """Real numbers are their real component."""
+ return +self
+
+ @property
+ def imag(self):
+ """Real numbers have no imaginary component."""
+ return 0
+
+ def conjugate(self):
+ """Conjugate is a no-op for Reals."""
+ return +self
+
+Real.register(float)
+
+
+class Rational(Real):
+ """.numerator and .denominator should be in lowest terms."""
+
+ __slots__ = ()
+
+ @property
+ @abstractmethod
+ def numerator(self):
+ raise NotImplementedError
+
+ @property
+ @abstractmethod
+ def denominator(self):
+ raise NotImplementedError
+
+ # Concrete implementation of Real's conversion to float.
+ def __float__(self):
+ """float(self) = self.numerator / self.denominator
+
+ It's important that this conversion use the integer's "true"
+ division rather than casting one side to float before dividing
+ so that ratios of huge integers convert without overflowing.
+
+ """
+ return self.numerator / self.denominator
+
+
+class Integral(Rational):
+ """Integral adds a conversion to int and the bit-string operations."""
+
+ __slots__ = ()
+
+ @abstractmethod
+ def __int__(self):
+ """int(self)"""
+ raise NotImplementedError
+
+ def __index__(self):
+ """Called whenever an index is needed, such as in slicing"""
+ return int(self)
+
+ @abstractmethod
+ def __pow__(self, exponent, modulus=None):
+ """self ** exponent % modulus, but maybe faster.
+
+ Accept the modulus argument if you want to support the
+ 3-argument version of pow(). Raise a TypeError if exponent < 0
+ or any argument isn't Integral. Otherwise, just implement the
+ 2-argument version described in Complex.
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def __lshift__(self, other):
+ """self << other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rlshift__(self, other):
+ """other << self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rshift__(self, other):
+ """self >> other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rrshift__(self, other):
+ """other >> self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __and__(self, other):
+ """self & other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rand__(self, other):
+ """other & self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __xor__(self, other):
+ """self ^ other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rxor__(self, other):
+ """other ^ self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __or__(self, other):
+ """self | other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __ror__(self, other):
+ """other | self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __invert__(self):
+ """~self"""
+ raise NotImplementedError
+
+ # Concrete implementations of Rational and Real abstract methods.
+ def __float__(self):
+ """float(self) == float(int(self))"""
+ return float(int(self))
+
+ @property
+ def numerator(self):
+ """Integers are their own numerators."""
+ return +self
+
+ @property
+ def denominator(self):
+ """Integers have a denominator of 1."""
+ return 1
+
+Integral.register(int)
--- /dev/null
+#
+# Secret Labs' Regular Expression Engine
+#
+# re-compatible interface for the sre matching engine
+#
+# Copyright (c) 1998-2001 by Secret Labs AB. All rights reserved.
+#
+# This version of the SRE library can be redistributed under CNRI's
+# Python 1.6 license. For any other use, please contact Secret Labs
+# AB (info@pythonware.com).
+#
+# Portions of this engine have been developed in cooperation with
+# CNRI. Hewlett-Packard provided funding for 1.6 integration and
+# other compatibility work.
+#
+
+r"""Support for regular expressions (RE).
+
+This module provides regular expression matching operations similar to
+those found in Perl. It supports both 8-bit and Unicode strings; both
+the pattern and the strings being processed can contain null bytes and
+characters outside the US ASCII range.
+
+Regular expressions can contain both special and ordinary characters.
+Most ordinary characters, like "A", "a", or "0", are the simplest
+regular expressions; they simply match themselves. You can
+concatenate ordinary characters, so last matches the string 'last'.
+
+The special characters are:
+ "." Matches any character except a newline.
+ "^" Matches the start of the string.
+ "$" Matches the end of the string or just before the newline at
+ the end of the string.
+ "*" Matches 0 or more (greedy) repetitions of the preceding RE.
+ Greedy means that it will match as many repetitions as possible.
+ "+" Matches 1 or more (greedy) repetitions of the preceding RE.
+ "?" Matches 0 or 1 (greedy) of the preceding RE.
+ *?,+?,?? Non-greedy versions of the previous three special characters.
+ {m,n} Matches from m to n repetitions of the preceding RE.
+ {m,n}? Non-greedy version of the above.
+ "\\" Either escapes special characters or signals a special sequence.
+ [] Indicates a set of characters.
+ A "^" as the first character indicates a complementing set.
+ "|" A|B, creates an RE that will match either A or B.
+ (...) Matches the RE inside the parentheses.
+ The contents can be retrieved or matched later in the string.
+ (?aiLmsux) Set the A, I, L, M, S, U, or X flag for the RE (see below).
+ (?:...) Non-grouping version of regular parentheses.
+ (?P<name>...) The substring matched by the group is accessible by name.
+ (?P=name) Matches the text matched earlier by the group named name.
+ (?#...) A comment; ignored.
+ (?=...) Matches if ... matches next, but doesn't consume the string.
+ (?!...) Matches if ... doesn't match next.
+ (?<=...) Matches if preceded by ... (must be fixed length).
+ (?<!...) Matches if not preceded by ... (must be fixed length).
+ (?(id/name)yes|no) Matches yes pattern if the group with id/name matched,
+ the (optional) no pattern otherwise.
+
+The special sequences consist of "\\" and a character from the list
+below. If the ordinary character is not on the list, then the
+resulting RE will match the second character.
+ \number Matches the contents of the group of the same number.
+ \A Matches only at the start of the string.
+ \Z Matches only at the end of the string.
+ \b Matches the empty string, but only at the start or end of a word.
+ \B Matches the empty string, but not at the start or end of a word.
+ \d Matches any decimal digit; equivalent to the set [0-9] in
+ bytes patterns or string patterns with the ASCII flag.
+ In string patterns without the ASCII flag, it will match the whole
+ range of Unicode digits.
+ \D Matches any non-digit character; equivalent to [^\d].
+ \s Matches any whitespace character; equivalent to [ \t\n\r\f\v] in
+ bytes patterns or string patterns with the ASCII flag.
+ In string patterns without the ASCII flag, it will match the whole
+ range of Unicode whitespace characters.
+ \S Matches any non-whitespace character; equivalent to [^\s].
+ \w Matches any alphanumeric character; equivalent to [a-zA-Z0-9_]
+ in bytes patterns or string patterns with the ASCII flag.
+ In string patterns without the ASCII flag, it will match the
+ range of Unicode alphanumeric characters (letters plus digits
+ plus underscore).
+ With LOCALE, it will match the set [0-9_] plus characters defined
+ as letters for the current locale.
+ \W Matches the complement of \w.
+ \\ Matches a literal backslash.
+
+This module exports the following functions:
+ match Match a regular expression pattern to the beginning of a string.
+ fullmatch Match a regular expression pattern to all of a string.
+ search Search a string for the presence of a pattern.
+ sub Substitute occurrences of a pattern found in a string.
+ subn Same as sub, but also return the number of substitutions made.
+ split Split a string by the occurrences of a pattern.
+ findall Find all occurrences of a pattern in a string.
+ finditer Return an iterator yielding a match object for each match.
+ compile Compile a pattern into a RegexObject.
+ purge Clear the regular expression cache.
+ escape Backslash all non-alphanumerics in a string.
+
+Some of the functions in this module takes flags as optional parameters:
+ A ASCII For string patterns, make \w, \W, \b, \B, \d, \D
+ match the corresponding ASCII character categories
+ (rather than the whole Unicode categories, which is the
+ default).
+ For bytes patterns, this flag is the only available
+ behaviour and needn't be specified.
+ I IGNORECASE Perform case-insensitive matching.
+ L LOCALE Make \w, \W, \b, \B, dependent on the current locale.
+ M MULTILINE "^" matches the beginning of lines (after a newline)
+ as well as the string.
+ "$" matches the end of lines (before a newline) as well
+ as the end of the string.
+ S DOTALL "." matches any character at all, including the newline.
+ X VERBOSE Ignore whitespace and comments for nicer looking RE's.
+ U UNICODE For compatibility only. Ignored for string patterns (it
+ is the default), and forbidden for bytes patterns.
+
+This module also defines an exception 'error'.
+
+"""
+
+import sys
+import sre_compile
+import sre_parse
+
+# public symbols
+__all__ = [ "match", "fullmatch", "search", "sub", "subn", "split", "findall",
+ "compile", "purge", "template", "escape", "A", "I", "L", "M", "S", "X",
+ "U", "ASCII", "IGNORECASE", "LOCALE", "MULTILINE", "DOTALL", "VERBOSE",
+ "UNICODE", "error" ]
+
+__version__ = "2.2.1"
+
+# flags
+A = ASCII = sre_compile.SRE_FLAG_ASCII # assume ascii "locale"
+I = IGNORECASE = sre_compile.SRE_FLAG_IGNORECASE # ignore case
+L = LOCALE = sre_compile.SRE_FLAG_LOCALE # assume current 8-bit locale
+U = UNICODE = sre_compile.SRE_FLAG_UNICODE # assume unicode "locale"
+M = MULTILINE = sre_compile.SRE_FLAG_MULTILINE # make anchors look for newline
+S = DOTALL = sre_compile.SRE_FLAG_DOTALL # make dot match newline
+X = VERBOSE = sre_compile.SRE_FLAG_VERBOSE # ignore whitespace and comments
+
+# sre extensions (experimental, don't rely on these)
+T = TEMPLATE = sre_compile.SRE_FLAG_TEMPLATE # disable backtracking
+DEBUG = sre_compile.SRE_FLAG_DEBUG # dump pattern after compilation
+
+# sre exception
+error = sre_compile.error
+
+# --------------------------------------------------------------------
+# public interface
+
+def match(pattern, string, flags=0):
+ """Try to apply the pattern at the start of the string, returning
+ a match object, or None if no match was found."""
+ return _compile(pattern, flags).match(string)
+
+def fullmatch(pattern, string, flags=0):
+ """Try to apply the pattern to all of the string, returning
+ a match object, or None if no match was found."""
+ return _compile(pattern, flags).fullmatch(string)
+
+def search(pattern, string, flags=0):
+ """Scan through string looking for a match to the pattern, returning
+ a match object, or None if no match was found."""
+ return _compile(pattern, flags).search(string)
+
+def sub(pattern, repl, string, count=0, flags=0):
+ """Return the string obtained by replacing the leftmost
+ non-overlapping occurrences of the pattern in string by the
+ replacement repl. repl can be either a string or a callable;
+ if a string, backslash escapes in it are processed. If it is
+ a callable, it's passed the match object and must return
+ a replacement string to be used."""
+ return _compile(pattern, flags).sub(repl, string, count)
+
+def subn(pattern, repl, string, count=0, flags=0):
+ """Return a 2-tuple containing (new_string, number).
+ new_string is the string obtained by replacing the leftmost
+ non-overlapping occurrences of the pattern in the source
+ string by the replacement repl. number is the number of
+ substitutions that were made. repl can be either a string or a
+ callable; if a string, backslash escapes in it are processed.
+ If it is a callable, it's passed the match object and must
+ return a replacement string to be used."""
+ return _compile(pattern, flags).subn(repl, string, count)
+
+def split(pattern, string, maxsplit=0, flags=0):
+ """Split the source string by the occurrences of the pattern,
+ returning a list containing the resulting substrings. If
+ capturing parentheses are used in pattern, then the text of all
+ groups in the pattern are also returned as part of the resulting
+ list. If maxsplit is nonzero, at most maxsplit splits occur,
+ and the remainder of the string is returned as the final element
+ of the list."""
+ return _compile(pattern, flags).split(string, maxsplit)
+
+def findall(pattern, string, flags=0):
+ """Return a list of all non-overlapping matches in the string.
+
+ If one or more capturing groups are present in the pattern, return
+ a list of groups; this will be a list of tuples if the pattern
+ has more than one group.
+
+ Empty matches are included in the result."""
+ return _compile(pattern, flags).findall(string)
+
+if sys.hexversion >= 0x02020000:
+ __all__.append("finditer")
+ def finditer(pattern, string, flags=0):
+ """Return an iterator over all non-overlapping matches in the
+ string. For each match, the iterator returns a match object.
+
+ Empty matches are included in the result."""
+ return _compile(pattern, flags).finditer(string)
+
+def compile(pattern, flags=0):
+ "Compile a regular expression pattern, returning a pattern object."
+ return _compile(pattern, flags)
+
+def purge():
+ "Clear the regular expression caches"
+ _cache.clear()
+ _cache_repl.clear()
+
+def template(pattern, flags=0):
+ "Compile a template pattern, returning a pattern object"
+ return _compile(pattern, flags|T)
+
+_alphanum_str = frozenset(
+ "_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890")
+_alphanum_bytes = frozenset(
+ b"_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ01234567890")
+
+def escape(pattern):
+ """
+ Escape all the characters in pattern except ASCII letters, numbers and '_'.
+ """
+ if isinstance(pattern, str):
+ alphanum = _alphanum_str
+ s = list(pattern)
+ for i, c in enumerate(pattern):
+ if c not in alphanum:
+ if c == "\000":
+ s[i] = "\\000"
+ else:
+ s[i] = "\\" + c
+ return "".join(s)
+ else:
+ alphanum = _alphanum_bytes
+ s = []
+ esc = ord(b"\\")
+ for c in pattern:
+ if c in alphanum:
+ s.append(c)
+ else:
+ if c == 0:
+ s.extend(b"\\000")
+ else:
+ s.append(esc)
+ s.append(c)
+ return bytes(s)
+
+# --------------------------------------------------------------------
+# internals
+
+_cache = {}
+_cache_repl = {}
+
+_pattern_type = type(sre_compile.compile("", 0))
+
+_MAXCACHE = 512
+def _compile(pattern, flags):
+ # internal: compile pattern
+ bypass_cache = flags & DEBUG
+ if not bypass_cache:
+ try:
+ return _cache[type(pattern), pattern, flags]
+ except KeyError:
+ pass
+ if isinstance(pattern, _pattern_type):
+ if flags:
+ raise ValueError(
+ "Cannot process flags argument with a compiled pattern")
+ return pattern
+ if not sre_compile.isstring(pattern):
+ raise TypeError("first argument must be string or compiled pattern")
+ p = sre_compile.compile(pattern, flags)
+ if not bypass_cache:
+ if len(_cache) >= _MAXCACHE:
+ _cache.clear()
+ _cache[type(pattern), pattern, flags] = p
+ return p
+
+def _compile_repl(repl, pattern):
+ # internal: compile replacement pattern
+ try:
+ return _cache_repl[repl, pattern]
+ except KeyError:
+ pass
+ p = sre_parse.parse_template(repl, pattern)
+ if len(_cache_repl) >= _MAXCACHE:
+ _cache_repl.clear()
+ _cache_repl[repl, pattern] = p
+ return p
+
+def _expand(pattern, match, template):
+ # internal: match.expand implementation hook
+ template = sre_parse.parse_template(template, pattern)
+ return sre_parse.expand_template(template, match)
+
+def _subx(pattern, template):
+ # internal: pattern.sub/subn implementation helper
+ template = _compile_repl(template, pattern)
+ if not template[0] and len(template[1]) == 1:
+ # literal replacement
+ return template[1][0]
+ def filter(match, template=template):
+ return sre_parse.expand_template(template, match)
+ return filter
+
+# register myself for pickling
+
+import copyreg
+
+def _pickle(p):
+ return _compile, (p.pattern, p.flags)
+
+copyreg.pickle(_pattern_type, _pickle, _compile)
+
+# --------------------------------------------------------------------
+# experimental stuff (see python-dev discussions for details)
+
+class Scanner:
+ def __init__(self, lexicon, flags=0):
+ from sre_constants import BRANCH, SUBPATTERN
+ self.lexicon = lexicon
+ # combine phrases into a compound pattern
+ p = []
+ s = sre_parse.Pattern()
+ s.flags = flags
+ for phrase, action in lexicon:
+ p.append(sre_parse.SubPattern(s, [
+ (SUBPATTERN, (len(p)+1, sre_parse.parse(phrase, flags))),
+ ]))
+ s.groups = len(p)+1
+ p = sre_parse.SubPattern(s, [(BRANCH, (None, p))])
+ self.scanner = sre_compile.compile(p)
+ def scan(self, string):
+ result = []
+ append = result.append
+ match = self.scanner.scanner(string).match
+ i = 0
+ while 1:
+ m = match()
+ if not m:
+ break
+ j = m.end()
+ if i == j:
+ break
+ action = self.lexicon[m.lastindex-1][1]
+ if callable(action):
+ self.match = m
+ action = action(self, m.group())
+ if action is not None:
+ append(action)
+ i = j
+ return result, string[i:]
--- /dev/null
+# placeholder for python interpreter
--- /dev/null
+# encoding: utf-8
+# module _io calls itself io
+# from (built-in)
+# by generator 1.135
+"""
+The io module provides the Python interfaces to stream handling. The
+builtin open function is defined in this module.
+
+At the top of the I/O hierarchy is the abstract base class IOBase. It
+defines the basic interface to a stream. Note, however, that there is no
+separation between reading and writing to streams; implementations are
+allowed to raise an IOError if they do not support a given operation.
+
+Extending IOBase is RawIOBase which deals simply with the reading and
+writing of raw bytes to a stream. FileIO subclasses RawIOBase to provide
+an interface to OS files.
+
+BufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its
+subclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer
+streams that are readable, writable, and both respectively.
+BufferedRandom provides a buffered interface to random access
+streams. BytesIO is a simple stream of in-memory bytes.
+
+Another IOBase subclass, TextIOBase, deals with the encoding and decoding
+of streams into text. TextIOWrapper, which extends it, is a buffered text
+interface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO
+is a in-memory stream for text.
+
+Argument names are not part of the specification, and only the arguments
+of open() are intended to be used as keyword arguments.
+
+data:
+
+DEFAULT_BUFFER_SIZE
+
+ An int containing the default buffer size used by the module's buffered
+ I/O classes. open() uses the file's blksize (as obtained by os.stat) if
+ possible.
+"""
+# no imports
+
+# Variables with simple values
+
+DEFAULT_BUFFER_SIZE = 8192
+
+# functions
+
+def open(name, mode=None, buffering=None): # known case of _io.open
+ """
+ open(file, mode='r', buffering=-1, encoding=None,
+ errors=None, newline=None, closefd=True, opener=None) -> file object
+
+ Open file and return a stream. Raise IOError upon failure.
+
+ file is either a text or byte string giving the name (and the path
+ if the file isn't in the current working directory) of the file to
+ be opened or an integer file descriptor of the file to be
+ wrapped. (If a file descriptor is given, it is closed when the
+ returned I/O object is closed, unless closefd is set to False.)
+
+ mode is an optional string that specifies the mode in which the file
+ is opened. It defaults to 'r' which means open for reading in text
+ mode. Other common values are 'w' for writing (truncating the file if
+ it already exists), 'x' for creating and writing to a new file, and
+ 'a' for appending (which on some Unix systems, means that all writes
+ append to the end of the file regardless of the current seek position).
+ In text mode, if encoding is not specified the encoding used is platform
+ dependent: locale.getpreferredencoding(False) is called to get the
+ current locale encoding. (For reading and writing raw bytes use binary
+ mode and leave encoding unspecified.) The available modes are:
+
+ ========= ===============================================================
+ Character Meaning
+ --------- ---------------------------------------------------------------
+ 'r' open for reading (default)
+ 'w' open for writing, truncating the file first
+ 'x' create a new file and open it for writing
+ 'a' open for writing, appending to the end of the file if it exists
+ 'b' binary mode
+ 't' text mode (default)
+ '+' open a disk file for updating (reading and writing)
+ 'U' universal newline mode (deprecated)
+ ========= ===============================================================
+
+ The default mode is 'rt' (open for reading text). For binary random
+ access, the mode 'w+b' opens and truncates the file to 0 bytes, while
+ 'r+b' opens the file without truncation. The 'x' mode implies 'w' and
+ raises an `FileExistsError` if the file already exists.
+
+ Python distinguishes between files opened in binary and text modes,
+ even when the underlying operating system doesn't. Files opened in
+ binary mode (appending 'b' to the mode argument) return contents as
+ bytes objects without any decoding. In text mode (the default, or when
+ 't' is appended to the mode argument), the contents of the file are
+ returned as strings, the bytes having been first decoded using a
+ platform-dependent encoding or using the specified encoding if given.
+
+ 'U' mode is deprecated and will raise an exception in future versions
+ of Python. It has no effect in Python 3. Use newline to control
+ universal newlines mode.
+
+ buffering is an optional integer used to set the buffering policy.
+ Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
+ line buffering (only usable in text mode), and an integer > 1 to indicate
+ the size of a fixed-size chunk buffer. When no buffering argument is
+ given, the default buffering policy works as follows:
+
+ * Binary files are buffered in fixed-size chunks; the size of the buffer
+ is chosen using a heuristic trying to determine the underlying device's
+ "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
+ On many systems, the buffer will typically be 4096 or 8192 bytes long.
+
+ * "Interactive" text files (files for which isatty() returns True)
+ use line buffering. Other text files use the policy described above
+ for binary files.
+
+ encoding is the name of the encoding used to decode or encode the
+ file. This should only be used in text mode. The default encoding is
+ platform dependent, but any encoding supported by Python can be
+ passed. See the codecs module for the list of supported encodings.
+
+ errors is an optional string that specifies how encoding errors are to
+ be handled---this argument should not be used in binary mode. Pass
+ 'strict' to raise a ValueError exception if there is an encoding error
+ (the default of None has the same effect), or pass 'ignore' to ignore
+ errors. (Note that ignoring encoding errors can lead to data loss.)
+ See the documentation for codecs.register or run 'help(codecs.Codec)'
+ for a list of the permitted encoding error strings.
+
+ newline controls how universal newlines works (it only applies to text
+ mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
+ follows:
+
+ * On input, if newline is None, universal newlines mode is
+ enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
+ these are translated into '\n' before being returned to the
+ caller. If it is '', universal newline mode is enabled, but line
+ endings are returned to the caller untranslated. If it has any of
+ the other legal values, input lines are only terminated by the given
+ string, and the line ending is returned to the caller untranslated.
+
+ * On output, if newline is None, any '\n' characters written are
+ translated to the system default line separator, os.linesep. If
+ newline is '' or '\n', no translation takes place. If newline is any
+ of the other legal values, any '\n' characters written are translated
+ to the given string.
+
+ If closefd is False, the underlying file descriptor will be kept open
+ when the file is closed. This does not work when a file name is given
+ and must be True in that case.
+
+ A custom opener can be used by passing a callable as *opener*. The
+ underlying file descriptor for the file object is then obtained by
+ calling *opener* with (*file*, *flags*). *opener* must return an open
+ file descriptor (passing os.open as *opener* results in functionality
+ similar to passing None).
+
+ open() returns a file object whose type depends on the mode, and
+ through which the standard file operations such as reading and writing
+ are performed. When open() is used to open a file in a text mode ('w',
+ 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
+ a file in a binary mode, the returned class varies: in read binary
+ mode, it returns a BufferedReader; in write binary and append binary
+ modes, it returns a BufferedWriter, and in read/write mode, it returns
+ a BufferedRandom.
+
+ It is also possible to use a string or bytearray as a file for both
+ reading and writing. For strings StringIO can be used like a file
+ opened in a text mode, and for bytes a BytesIO can be used like a file
+ opened in a binary mode.
+ """
+ return file('/dev/null')
+
+# classes
+
+from .OSError import OSError
+
+class BlockingIOError(OSError):
+ """ I/O operation would block. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .object import object
+
+class _IOBase(object):
+ """
+ The abstract base class for all I/O classes, acting on streams of
+ bytes. There is no public constructor.
+
+ This class provides dummy implementations for many methods that
+ derived classes can override selectively; the default implementations
+ represent a file that cannot be read, written or seeked.
+
+ Even though IOBase does not declare read, readinto, or write because
+ their signatures will vary, implementations and clients should
+ consider those methods part of the interface. Also, implementations
+ may raise UnsupportedOperation when operations they do not support are
+ called.
+
+ The basic type used for binary data read from or written to a file is
+ bytes. bytearrays are accepted too, and in some cases (such as
+ readinto) needed. Text I/O classes work with str data.
+
+ Note that calling any method (except additional calls to close(),
+ which are ignored) on a closed stream should raise a ValueError.
+
+ IOBase (and its subclasses) support the iterator protocol, meaning
+ that an IOBase object can be iterated over yielding the lines in a
+ stream.
+
+ IOBase also supports the :keyword:`with` statement. In this example,
+ fp is closed after the suite of the with statement is complete:
+
+ with open('spam.txt', 'r') as fp:
+ fp.write('Spam and eggs!')
+ """
+ def close(self, *args, **kwargs): # real signature unknown
+ """
+ Flush and close the IO object.
+
+ This method has no effect if the file is already closed.
+ """
+ pass
+
+ def fileno(self, *args, **kwargs): # real signature unknown
+ """
+ Returns underlying file descriptor if one exists.
+
+ An IOError is raised if the IO object does not use a file descriptor.
+ """
+ pass
+
+ def flush(self, *args, **kwargs): # real signature unknown
+ """
+ Flush write buffers, if applicable.
+
+ This is not implemented for read-only and non-blocking streams.
+ """
+ pass
+
+ def isatty(self, *args, **kwargs): # real signature unknown
+ """
+ Return whether this is an 'interactive' stream.
+
+ Return False if it can't be determined.
+ """
+ pass
+
+ def readable(self, *args, **kwargs): # real signature unknown
+ """
+ Return whether object was opened for reading.
+
+ If False, read() will raise UnsupportedOperation.
+ """
+ pass
+
+ def readline(self, *args, **kwargs): # real signature unknown
+ """
+ Read and return a line from the stream.
+
+ If limit is specified, at most limit bytes will be read.
+
+ The line terminator is always b'\n' for binary files; for text
+ files, the newlines argument to open can be used to select the line
+ terminator(s) recognized.
+ """
+ pass
+
+ def readlines(self, *args, **kwargs): # real signature unknown
+ """
+ Return a list of lines from the stream.
+
+ hint can be specified to control the number of lines read: no more
+ lines will be read if the total size (in bytes/characters) of all
+ lines so far exceeds hint.
+ """
+ pass
+
+ def seek(self, *args, **kwargs): # real signature unknown
+ """
+ Change stream position.
+
+ Change the stream position to the given byte offset. The offset is
+ interpreted relative to the position indicated by whence. Values
+ for whence are:
+
+ * 0 -- start of stream (the default); offset should be zero or positive
+ * 1 -- current stream position; offset may be negative
+ * 2 -- end of stream; offset is usually negative
+
+ Return the new absolute position.
+ """
+ pass
+
+ def seekable(self, *args, **kwargs): # real signature unknown
+ """
+ Return whether object supports random access.
+
+ If False, seek(), tell() and truncate() will raise UnsupportedOperation.
+ This method may need to do a test seek().
+ """
+ pass
+
+ def tell(self, *args, **kwargs): # real signature unknown
+ """ Return current stream position. """
+ pass
+
+ def truncate(self, *args, **kwargs): # real signature unknown
+ """
+ Truncate file to size bytes.
+
+ File pointer is left unchanged. Size defaults to the current IO
+ position as reported by tell(). Returns the new size.
+ """
+ pass
+
+ def writable(self, *args, **kwargs): # real signature unknown
+ """
+ Return whether object was opened for writing.
+
+ If False, write() will raise UnsupportedOperation.
+ """
+ pass
+
+ def writelines(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _checkClosed(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _checkReadable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _checkSeekable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _checkWritable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __del__(self, *args, **kwargs): # real signature unknown
+ """ """
+ pass
+
+ def __enter__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __exit__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+ __dict__ = None # (!) real value is ''
+
+
+from ._IOBase import _IOBase
+
+class _BufferedIOBase(_IOBase):
+ """
+ Base class for buffered IO objects.
+
+ The main difference with RawIOBase is that the read() method
+ supports omitting the size argument, and does not have a default
+ implementation that defers to readinto().
+
+ In addition, read(), readinto() and write() may raise
+ BlockingIOError if the underlying raw stream is in non-blocking
+ mode and not ready; unlike their raw counterparts, they will never
+ return None.
+
+ A typical implementation should not inherit from a RawIOBase
+ implementation, but wrap one.
+ """
+ def detach(self, *args, **kwargs): # real signature unknown
+ """
+ Disconnect this buffer from its underlying raw stream and return it.
+
+ After the raw stream has been detached, the buffer is in an unusable
+ state.
+ """
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ """
+ Read and return up to n bytes.
+
+ If the argument is omitted, None, or negative, reads and
+ returns all data until EOF.
+
+ If the argument is positive, and the underlying raw stream is
+ not 'interactive', multiple raw reads may be issued to satisfy
+ the byte count (unless EOF is reached first). But for
+ interactive raw streams (as well as sockets and pipes), at most
+ one raw read will be issued, and a short result does not imply
+ that EOF is imminent.
+
+ Returns an empty bytes object on EOF.
+
+ Returns None if the underlying raw stream was open in non-blocking
+ mode and no data is available at the moment.
+ """
+ pass
+
+ def read1(self, *args, **kwargs): # real signature unknown
+ """
+ Read and return up to n bytes, with at most one read() call
+ to the underlying raw stream. A short result does not imply
+ that EOF is imminent.
+
+ Returns an empty bytes object on EOF.
+ """
+ pass
+
+ def readinto(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ """
+ Write the given buffer to the IO stream.
+
+ Returns the number of bytes written, which is never less than
+ len(b).
+
+ Raises BlockingIOError if the buffer is full and the
+ underlying raw stream cannot accept more data at the moment.
+ """
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from ._BufferedIOBase import _BufferedIOBase
+
+class BufferedRandom(_BufferedIOBase):
+ """
+ A buffered interface to random access streams.
+
+ The constructor creates a reader and writer for a seekable stream,
+ raw, given in the first argument. If the buffer_size is omitted it
+ defaults to DEFAULT_BUFFER_SIZE.
+ """
+ def close(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def detach(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def fileno(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def flush(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def isatty(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def peek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read1(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readinto(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readline(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seekable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def tell(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def truncate(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def writable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _dealloc_warn(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __sizeof__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ mode = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ raw = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from ._BufferedIOBase import _BufferedIOBase
+
+class BufferedReader(_BufferedIOBase):
+ """ Create a new buffered reader using the given readable raw IO object. """
+ def close(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def detach(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def fileno(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def flush(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def isatty(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def peek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read1(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readinto(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readline(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seekable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def tell(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def truncate(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def writable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _dealloc_warn(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __sizeof__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ mode = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ raw = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from ._BufferedIOBase import _BufferedIOBase
+
+class BufferedRWPair(_BufferedIOBase):
+ """
+ A buffered reader and writer object together.
+
+ A buffered reader object and buffered writer object put together to
+ form a sequential IO object that can read and write. This is typically
+ used with a socket or two-way pipe.
+
+ reader and writer are RawIOBase objects that are readable and
+ writeable respectively. If the buffer_size is omitted it defaults to
+ DEFAULT_BUFFER_SIZE.
+ """
+ def close(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def flush(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def isatty(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def peek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read1(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readinto(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def writable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from ._BufferedIOBase import _BufferedIOBase
+
+class BufferedWriter(_BufferedIOBase):
+ """
+ A buffer for a writeable sequential RawIO object.
+
+ The constructor creates a BufferedWriter for the given writeable raw
+ stream. If the buffer_size is not given, it defaults to
+ DEFAULT_BUFFER_SIZE.
+ """
+ def close(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def detach(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def fileno(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def flush(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def isatty(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seekable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def tell(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def truncate(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def writable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def _dealloc_warn(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __sizeof__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ mode = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ raw = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from ._BufferedIOBase import _BufferedIOBase
+
+class BytesIO(_BufferedIOBase):
+ """
+ BytesIO([buffer]) -> object
+
+ Create a buffered I/O implementation using an in-memory bytes
+ buffer, ready for reading and writing.
+ """
+ def close(self): # real signature unknown; restored from __doc__
+ """ close() -> None. Disable all I/O operations. """
+ pass
+
+ def flush(self): # real signature unknown; restored from __doc__
+ """ flush() -> None. Does nothing. """
+ pass
+
+ def getbuffer(self): # real signature unknown; restored from __doc__
+ """
+ getbuffer() -> bytes.
+
+ Get a read-write view over the contents of the BytesIO object.
+ """
+ pass
+
+ def getvalue(self): # real signature unknown; restored from __doc__
+ """
+ getvalue() -> bytes.
+
+ Retrieve the entire contents of the BytesIO object.
+ """
+ pass
+
+ def isatty(self): # real signature unknown; restored from __doc__
+ """
+ isatty() -> False.
+
+ Always returns False since BytesIO objects are not connected
+ to a tty-like device.
+ """
+ pass
+
+ def read(self, size=None): # real signature unknown; restored from __doc__
+ """
+ read([size]) -> read at most size bytes, returned as a string.
+
+ If the size argument is negative, read until EOF is reached.
+ Return an empty string at EOF.
+ """
+ pass
+
+ def read1(self, size): # real signature unknown; restored from __doc__
+ """
+ read1(size) -> read at most size bytes, returned as a string.
+
+ If the size argument is negative or omitted, read until EOF is reached.
+ Return an empty string at EOF.
+ """
+ pass
+
+ def readable(self): # real signature unknown; restored from __doc__
+ """ readable() -> bool. Returns True if the IO object can be read. """
+ pass
+
+ def readinto(self, bytearray): # real signature unknown; restored from __doc__
+ """
+ readinto(bytearray) -> int. Read up to len(b) bytes into b.
+
+ Returns number of bytes read (0 for EOF), or None if the object
+ is set not to block as has no data to read.
+ """
+ pass
+
+ def readline(self, size=None): # real signature unknown; restored from __doc__
+ """
+ readline([size]) -> next line from the file, as a string.
+
+ Retain newline. A non-negative size argument limits the maximum
+ number of bytes to return (an incomplete line may be returned then).
+ Return an empty string at EOF.
+ """
+ pass
+
+ def readlines(self, size=None): # real signature unknown; restored from __doc__
+ """
+ readlines([size]) -> list of strings, each a line from the file.
+
+ Call readline() repeatedly and return a list of the lines so read.
+ The optional size argument, if given, is an approximate bound on the
+ total number of bytes in the lines returned.
+ """
+ return []
+
+ def seek(self, pos, whence=0): # real signature unknown; restored from __doc__
+ """
+ seek(pos, whence=0) -> int. Change stream position.
+
+ Seek to byte offset pos relative to position indicated by whence:
+ 0 Start of stream (the default). pos should be >= 0;
+ 1 Current position - pos may be negative;
+ 2 End of stream - pos usually negative.
+ Returns the new absolute position.
+ """
+ pass
+
+ def seekable(self): # real signature unknown; restored from __doc__
+ """ seekable() -> bool. Returns True if the IO object can be seeked. """
+ pass
+
+ def tell(self): # real signature unknown; restored from __doc__
+ """ tell() -> current file position, an integer """
+ pass
+
+ def truncate(self, size=None): # real signature unknown; restored from __doc__
+ """
+ truncate([size]) -> int. Truncate the file to at most size bytes.
+
+ Size defaults to the current file position, as returned by tell().
+ The current file position is unchanged. Returns the new size.
+ """
+ pass
+
+ def writable(self): # real signature unknown; restored from __doc__
+ """ writable() -> bool. Returns True if the IO object can be written. """
+ pass
+
+ def write(self, bytes): # real signature unknown; restored from __doc__
+ """
+ write(bytes) -> int. Write bytes to file.
+
+ Return the number of bytes written.
+ """
+ pass
+
+ def writelines(self, sequence_of_strings): # real signature unknown; restored from __doc__
+ """
+ writelines(sequence_of_strings) -> None. Write strings to the file.
+
+ Note that newlines are not added. The sequence can be any iterable
+ object producing strings. This is equivalent to calling write() for
+ each string.
+ """
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, buffer=None): # real signature unknown; restored from __doc__
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __setstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __sizeof__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """True if the file is closed."""
+
+
+
+from ._IOBase import _IOBase
+
+class _RawIOBase(_IOBase):
+ """ Base class for raw binary I/O. """
+ def read(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readall(self, *args, **kwargs): # real signature unknown
+ """ Read until EOF, using multiple read() call. """
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from ._RawIOBase import _RawIOBase
+
+class FileIO(_RawIOBase):
+ """
+ file(name: str[, mode: str][, opener: None]) -> file IO object
+
+ Open a file. The mode can be 'r', 'w', 'x' or 'a' for reading (default),
+ writing, exclusive creation or appending. The file will be created if it
+ doesn't exist when opened for writing or appending; it will be truncated
+ when opened for writing. A `FileExistsError` will be raised if it already
+ exists when opened for creating. Opening a file for creating implies
+ writing so this mode behaves in a similar way to 'w'.Add a '+' to the mode
+ to allow simultaneous reading and writing. A custom opener can be used by
+ passing a callable as *opener*. The underlying file descriptor for the file
+ object is then obtained by calling opener with (*name*, *flags*).
+ *opener* must return an open file descriptor (passing os.open as *opener*
+ results in functionality similar to passing None).
+ """
+ def close(self): # real signature unknown; restored from __doc__
+ """
+ close() -> None. Close the file.
+
+ A closed file cannot be used for further I/O operations. close() may be
+ called more than once without error. Changes the fileno to -1.
+ """
+ pass
+
+ def fileno(self): # real signature unknown; restored from __doc__
+ """
+ fileno() -> int. "file descriptor".
+
+ This is needed for lower-level file interfaces, such the fcntl module.
+ """
+ pass
+
+ def isatty(self): # real signature unknown; restored from __doc__
+ """ isatty() -> bool. True if the file is connected to a tty device. """
+ pass
+
+ def read(self, size=-1): # known case of _io.FileIO.read
+ """
+ read(size: int) -> bytes. read at most size bytes, returned as bytes.
+
+ Only makes one system call, so less data may be returned than requested
+ In non-blocking mode, returns None if no data is available.
+ On end-of-file, returns ''.
+ """
+ return ""
+
+ def readable(self): # real signature unknown; restored from __doc__
+ """ readable() -> bool. True if file was opened in a read mode. """
+ pass
+
+ def readall(self): # real signature unknown; restored from __doc__
+ """
+ readall() -> bytes. read all data from the file, returned as bytes.
+
+ In non-blocking mode, returns as much as is immediately available,
+ or None if no data is available. On end-of-file, returns ''.
+ """
+ pass
+
+ def readinto(self): # real signature unknown; restored from __doc__
+ """ readinto() -> Same as RawIOBase.readinto(). """
+ pass
+
+ def seek(self, offset, whence=None): # real signature unknown; restored from __doc__
+ """
+ seek(offset: int[, whence: int]) -> None. Move to new file position.
+
+ Argument offset is a byte count. Optional argument whence defaults to
+ 0 (offset from start of file, offset should be >= 0); other values are 1
+ (move relative to current position, positive or negative), and 2 (move
+ relative to end of file, usually negative, although many platforms allow
+ seeking beyond the end of a file).
+ Note that not all file objects are seekable.
+ """
+ pass
+
+ def seekable(self): # real signature unknown; restored from __doc__
+ """ seekable() -> bool. True if file supports random-access. """
+ pass
+
+ def tell(self): # real signature unknown; restored from __doc__
+ """ tell() -> int. Current file position """
+ pass
+
+ def truncate(self, size=None): # real signature unknown; restored from __doc__
+ """
+ truncate([size: int]) -> None. Truncate the file to at most size bytes.
+
+ Size defaults to the current file position, as returned by tell().The current file position is changed to the value of size.
+ """
+ pass
+
+ def writable(self): # real signature unknown; restored from __doc__
+ """ writable() -> bool. True if file was opened in a write mode. """
+ pass
+
+ def write(self, b): # real signature unknown; restored from __doc__
+ """
+ write(b: bytes) -> int. Write bytes b to file, return number written.
+
+ Only makes one system call, so not all of the data may be written.
+ The number of bytes actually written is returned.
+ """
+ pass
+
+ def _dealloc_warn(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """True if the file is closed"""
+
+ closefd = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """True if the file descriptor will be closed"""
+
+ mode = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """String giving the file mode"""
+
+ _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from .object import object
+
+class IncrementalNewlineDecoder(object):
+ """
+ Codec used when reading a file in universal newlines mode. It wraps
+ another incremental decoder, translating \r\n and \r into \n. It also
+ records the types of newlines encountered. When used with
+ translate=False, it ensures that the newline sequence is returned in
+ one piece. When used with decoder=None, it expects unicode strings as
+ decode input and translates newlines without first invoking an external
+ decoder.
+ """
+ def decode(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def getstate(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def reset(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def setstate(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from ._IOBase import _IOBase
+
+class _TextIOBase(_IOBase):
+ """
+ Base class for text I/O.
+
+ This class provides a character and line based interface to stream
+ I/O. There is no readinto method because Python's character strings
+ are immutable. There is no public constructor.
+ """
+ def detach(self, *args, **kwargs): # real signature unknown
+ """
+ Separate the underlying buffer from the TextIOBase and return it.
+
+ After the underlying buffer has been detached, the TextIO is in an
+ unusable state.
+ """
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ """
+ Read at most n characters from stream.
+
+ Read from underlying buffer until we have n characters or we hit EOF.
+ If n is negative or omitted, read until EOF.
+ """
+ pass
+
+ def readline(self, *args, **kwargs): # real signature unknown
+ """
+ Read until newline or EOF.
+
+ Returns an empty string if EOF is hit immediately.
+ """
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ """
+ Write string to stream.
+ Returns the number of characters written (which is always equal to
+ the length of the string).
+ """
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ encoding = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """Encoding of the text stream.
+
+Subclasses should override.
+"""
+
+ errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """The error setting of the decoder or encoder.
+
+Subclasses should override.
+"""
+
+ newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """Line endings translated so far.
+
+Only line endings translated during reading are considered.
+
+Subclasses should override.
+"""
+
+
+
+from ._TextIOBase import _TextIOBase
+
+class StringIO(_TextIOBase):
+ """
+ Text I/O implementation using an in-memory buffer.
+
+ The initial_value argument sets the value of object. The newline
+ argument is like the one of TextIOWrapper's constructor.
+ """
+ def close(self, *args, **kwargs): # real signature unknown
+ """
+ Close the IO object. Attempting any further operation after the
+ object is closed will raise a ValueError.
+
+ This method has no effect if the file is already closed.
+ """
+ pass
+
+ def getvalue(self, *args, **kwargs): # real signature unknown
+ """ Retrieve the entire contents of the object. """
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ """
+ Read at most n characters, returned as a string.
+
+ If the argument is negative or omitted, read until EOF
+ is reached. Return an empty string at EOF.
+ """
+ pass
+
+ def readable(self): # real signature unknown; restored from __doc__
+ """ readable() -> bool. Returns True if the IO object can be read. """
+ pass
+
+ def readline(self, *args, **kwargs): # real signature unknown
+ """
+ Read until newline or EOF.
+
+ Returns an empty string if EOF is hit immediately.
+ """
+ pass
+
+ def seek(self, *args, **kwargs): # real signature unknown
+ """
+ Change stream position.
+
+ Seek to character offset pos relative to position indicated by whence:
+ 0 Start of stream (the default). pos should be >= 0;
+ 1 Current position - pos must be 0;
+ 2 End of stream - pos must be 0.
+ Returns the new absolute position.
+ """
+ pass
+
+ def seekable(self): # real signature unknown; restored from __doc__
+ """ seekable() -> bool. Returns True if the IO object can be seeked. """
+ pass
+
+ def tell(self, *args, **kwargs): # real signature unknown
+ """ Tell the current file position. """
+ pass
+
+ def truncate(self, *args, **kwargs): # real signature unknown
+ """
+ Truncate size to pos.
+
+ The pos argument defaults to the current file position, as
+ returned by tell(). The current file position is unchanged.
+ Returns the new absolute position.
+ """
+ pass
+
+ def writable(self): # real signature unknown; restored from __doc__
+ """ writable() -> bool. Returns True if the IO object can be written. """
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ """
+ Write string to file.
+
+ Returns the number of characters written, which is always equal to
+ the length of the string.
+ """
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __setstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from ._TextIOBase import _TextIOBase
+
+class TextIOWrapper(_TextIOBase):
+ """
+ Character and line based layer over a BufferedIOBase object, buffer.
+
+ encoding gives the name of the encoding that the stream will be
+ decoded or encoded with. It defaults to locale.getpreferredencoding(False).
+
+ errors determines the strictness of encoding and decoding (see
+ help(codecs.Codec) or the documentation for codecs.register) and
+ defaults to "strict".
+
+ newline controls how line endings are handled. It can be None, '',
+ '\n', '\r', and '\r\n'. It works as follows:
+
+ * On input, if newline is None, universal newlines mode is
+ enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
+ these are translated into '\n' before being returned to the
+ caller. If it is '', universal newline mode is enabled, but line
+ endings are returned to the caller untranslated. If it has any of
+ the other legal values, input lines are only terminated by the given
+ string, and the line ending is returned to the caller untranslated.
+
+ * On output, if newline is None, any '\n' characters written are
+ translated to the system default line separator, os.linesep. If
+ newline is '' or '\n', no translation takes place. If newline is any
+ of the other legal values, any '\n' characters written are translated
+ to the given string.
+
+ If line_buffering is True, a call to flush is implied when a call to
+ write contains a newline character.
+ """
+ def close(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def detach(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def fileno(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def flush(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def isatty(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def read(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def readline(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seek(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def seekable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def tell(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def truncate(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def writable(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def write(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ buffer = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ closed = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ encoding = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ errors = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ line_buffering = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ name = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ newlines = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ _CHUNK_SIZE = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ _finalizing = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+
+from .ValueError import ValueError
+
+from .OSError import OSError
+
+class UnsupportedOperation(ValueError, OSError):
+ # no doc
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """list of weak references to the object (if defined)"""
+
+
+
+from .object import object
+
+class __loader__(object):
+ """
+ Meta path import for built-in modules.
+
+ All methods are either class or static methods to avoid the need to
+ instantiate the class.
+ """
+ @classmethod
+ def find_module(cls, *args, **kwargs): # real signature unknown
+ """
+ Find the built-in module.
+
+ If 'path' is ever specified then the search is considered a failure.
+
+ This method is deprecated. Use find_spec() instead.
+ """
+ pass
+
+ @classmethod
+ def find_spec(cls, *args, **kwargs): # real signature unknown
+ pass
+
+ @classmethod
+ def get_code(cls, *args, **kwargs): # real signature unknown
+ """ Return None as built-in modules do not have code objects. """
+ pass
+
+ @classmethod
+ def get_source(cls, *args, **kwargs): # real signature unknown
+ """ Return None as built-in modules do not have source code. """
+ pass
+
+ @classmethod
+ def is_package(cls, *args, **kwargs): # real signature unknown
+ """ Return False as built-in modules are never packages. """
+ pass
+
+ @classmethod
+ def load_module(cls, *args, **kwargs): # real signature unknown
+ """ Load a built-in module. """
+ pass
+
+ def module_repr(module): # reliably restored by inspect
+ """
+ Return repr for the module.
+
+ The method is deprecated. The import machinery does the job itself.
+ """
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """list of weak references to the object (if defined)"""
+
+
+ __dict__ = None # (!) real value is ''
+
+
+# variables with complex values
+
+__spec__ = None # (!) real value is ''
+
--- /dev/null
+# encoding: utf-8
+# module builtins
+# from (built-in)
+# by generator 1.135
+"""
+Built-in functions, exceptions, and other objects.
+
+Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.
+"""
+# no imports
+
+# Variables with simple values
+# definition of False omitted
+# definition of None omitted
+# definition of True omitted
+# definition of __debug__ omitted
+
+# functions
+from object import object
+
+def abs(number): # real signature unknown; restored from __doc__
+ """
+ abs(number) -> number
+
+ Return the absolute value of the argument.
+ """
+ return 0
+
+def all(iterable): # real signature unknown; restored from __doc__
+ """
+ all(iterable) -> bool
+
+ Return True if bool(x) is True for all values x in the iterable.
+ If the iterable is empty, return True.
+ """
+ return False
+
+def any(iterable): # real signature unknown; restored from __doc__
+ """
+ any(iterable) -> bool
+
+ Return True if bool(x) is True for any x in the iterable.
+ If the iterable is empty, return False.
+ """
+ return False
+
+def ascii(p_object): # real signature unknown; restored from __doc__
+ """
+ ascii(object) -> string
+
+ As repr(), return a string containing a printable representation of an
+ object, but escape the non-ASCII characters in the string returned by
+ repr() using \x, \u or \U escapes. This generates a string similar
+ to that returned by repr() in Python 2.
+ """
+ return ""
+
+def bin(number): # real signature unknown; restored from __doc__
+ """
+ bin(number) -> string
+
+ Return the binary representation of an integer.
+
+ >>> bin(2796202)
+ '0b1010101010101010101010'
+ """
+ return ""
+
+def callable(p_object): # real signature unknown; restored from __doc__
+ """
+ callable(object) -> bool
+
+ Return whether the object is callable (i.e., some kind of function).
+ Note that classes are callable, as are instances of classes with a
+ __call__() method.
+ """
+ return False
+
+def chr(i): # real signature unknown; restored from __doc__
+ """
+ chr(i) -> Unicode character
+
+ Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
+ """
+ return ""
+
+def compile(source, filename, mode, flags=None, dont_inherit=None): # real signature unknown; restored from __doc__
+ """
+ compile(source, filename, mode[, flags[, dont_inherit]]) -> code object
+
+ Compile the source (a Python module, statement or expression)
+ into a code object that can be executed by exec() or eval().
+ The filename will be used for run-time error messages.
+ The mode must be 'exec' to compile a module, 'single' to compile a
+ single (interactive) statement, or 'eval' to compile an expression.
+ The flags argument, if present, controls which future statements influence
+ the compilation of the code.
+ The dont_inherit argument, if non-zero, stops the compilation inheriting
+ the effects of any future statements in effect in the code calling
+ compile; if absent or zero these statements do influence the compilation,
+ in addition to any features explicitly specified.
+ """
+ pass
+
+def copyright(*args, **kwargs): # real signature unknown
+ """
+ interactive prompt objects for printing the license text, a list of
+ contributors and the copyright notice.
+ """
+ pass
+
+def credits(*args, **kwargs): # real signature unknown
+ """
+ interactive prompt objects for printing the license text, a list of
+ contributors and the copyright notice.
+ """
+ pass
+
+def delattr(p_object, name): # real signature unknown; restored from __doc__
+ """
+ delattr(object, name)
+
+ Delete a named attribute on an object; delattr(x, 'y') is equivalent to
+ ``del x.y''.
+ """
+ pass
+
+def dir(p_object=None): # real signature unknown; restored from __doc__
+ """
+ dir([object]) -> list of strings
+
+ If called without an argument, return the names in the current scope.
+ Else, return an alphabetized list of names comprising (some of) the attributes
+ of the given object, and of attributes reachable from it.
+ If the object supplies a method named __dir__, it will be used; otherwise
+ the default dir() logic is used and returns:
+ for a module object: the module's attributes.
+ for a class object: its attributes, and recursively the attributes
+ of its bases.
+ for any other object: its attributes, its class's attributes, and
+ recursively the attributes of its class's base classes.
+ """
+ return []
+
+def divmod(x, y): # known case of builtins.divmod
+ """
+ divmod(x, y) -> (div, mod)
+
+ Return the tuple ((x-x%y)/y, x%y). Invariant: div*y + mod == x.
+ """
+ return (0, 0)
+
+def eval(source, globals=None, locals=None): # real signature unknown; restored from __doc__
+ """
+ eval(source[, globals[, locals]]) -> value
+
+ Evaluate the source in the context of globals and locals.
+ The source may be a string representing a Python expression
+ or a code object as returned by compile().
+ The globals must be a dictionary and locals can be any mapping,
+ defaulting to the current globals and locals.
+ If only globals is given, locals defaults to it.
+ """
+ pass
+
+def exec(p_object, globals=None, locals=None): # real signature unknown; restored from __doc__
+ """
+ exec(object[, globals[, locals]])
+
+ Read and execute code from an object, which can be a string or a code
+ object.
+ The globals and locals are dictionaries, defaulting to the current
+ globals and locals. If only globals is given, locals defaults to it.
+ """
+ pass
+
+def exit(*args, **kwargs): # real signature unknown
+ pass
+
+def format(value, format_spec=None): # real signature unknown; restored from __doc__
+ """
+ format(value[, format_spec]) -> string
+
+ Returns value.__format__(format_spec)
+ format_spec defaults to ""
+ """
+ return ""
+
+def getattr(object, name, default=None): # known special case of getattr
+ """
+ getattr(object, name[, default]) -> value
+
+ Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
+ When a default argument is given, it is returned when the attribute doesn't
+ exist; without it, an exception is raised in that case.
+ """
+ pass
+
+def globals(): # real signature unknown; restored from __doc__
+ """
+ globals() -> dictionary
+
+ Return the dictionary containing the current scope's global variables.
+ """
+ return {}
+
+def hasattr(p_object, name): # real signature unknown; restored from __doc__
+ """
+ hasattr(object, name) -> bool
+
+ Return whether the object has an attribute with the given name.
+ (This is done by calling getattr(object, name) and catching AttributeError.)
+ """
+ return False
+
+def hash(p_object): # real signature unknown; restored from __doc__
+ """
+ hash(object) -> integer
+
+ Return a hash value for the object. Two objects with the same value have
+ the same hash value. The reverse is not necessarily true, but likely.
+ """
+ return 0
+
+def help(): # real signature unknown; restored from __doc__
+ """
+ Define the builtin 'help'.
+
+ This is a wrapper around pydoc.help that provides a helpful message
+ when 'help' is typed at the Python interactive prompt.
+
+ Calling help() at the Python prompt starts an interactive help session.
+ Calling help(thing) prints help for the python object 'thing'.
+ """
+ pass
+
+def hex(number): # real signature unknown; restored from __doc__
+ """
+ hex(number) -> string
+
+ Return the hexadecimal representation of an integer.
+
+ >>> hex(3735928559)
+ '0xdeadbeef'
+ """
+ return ""
+
+def id(p_object): # real signature unknown; restored from __doc__
+ """
+ id(object) -> integer
+
+ Return the identity of an object. This is guaranteed to be unique among
+ simultaneously existing objects. (Hint: it's the object's memory address.)
+ """
+ return 0
+
+def input(prompt=None): # real signature unknown; restored from __doc__
+ """
+ input([prompt]) -> string
+
+ Read a string from standard input. The trailing newline is stripped.
+ If the user hits EOF (Unix: Ctl-D, Windows: Ctl-Z+Return), raise EOFError.
+ On Unix, GNU readline is used if enabled. The prompt string, if given,
+ is printed without a trailing newline before reading.
+ """
+ return ""
+
+def isinstance(p_object, class_or_type_or_tuple): # real signature unknown; restored from __doc__
+ """
+ isinstance(object, class-or-type-or-tuple) -> bool
+
+ Return whether an object is an instance of a class or of a subclass thereof.
+ With a type as second argument, return whether that is the object's type.
+ The form using a tuple, isinstance(x, (A, B, ...)), is a shortcut for
+ isinstance(x, A) or isinstance(x, B) or ... (etc.).
+ """
+ return False
+
+def issubclass(C, B): # real signature unknown; restored from __doc__
+ """
+ issubclass(C, B) -> bool
+
+ Return whether class C is a subclass (i.e., a derived class) of class B.
+ When using a tuple as the second argument issubclass(X, (A, B, ...)),
+ is a shortcut for issubclass(X, A) or issubclass(X, B) or ... (etc.).
+ """
+ return False
+
+def iter(source, sentinel=None): # known special case of iter
+ """
+ iter(iterable) -> iterator
+ iter(callable, sentinel) -> iterator
+
+ Get an iterator from an object. In the first form, the argument must
+ supply its own iterator, or be a sequence.
+ In the second form, the callable is called until it returns the sentinel.
+ """
+ pass
+
+def len(p_object): # real signature unknown; restored from __doc__
+ """
+ len(object)
+
+ Return the number of items of a sequence or mapping.
+ """
+ pass
+
+def license(*args, **kwargs): # real signature unknown
+ """
+ interactive prompt objects for printing the license text, a list of
+ contributors and the copyright notice.
+ """
+ pass
+
+def locals(): # real signature unknown; restored from __doc__
+ """
+ locals() -> dictionary
+
+ Update and return a dictionary containing the current scope's local variables.
+ """
+ return {}
+
+def max(*args, key=None): # known special case of max
+ """
+ max(iterable[, key=func]) -> value
+ max(a, b, c, ...[, key=func]) -> value
+
+ With a single iterable argument, return its largest item.
+ With two or more arguments, return the largest argument.
+ """
+ pass
+
+def min(*args, key=None): # known special case of min
+ """
+ min(iterable[, key=func]) -> value
+ min(a, b, c, ...[, key=func]) -> value
+
+ With a single iterable argument, return its smallest item.
+ With two or more arguments, return the smallest argument.
+ """
+ pass
+
+def next(iterator, default=None): # real signature unknown; restored from __doc__
+ """
+ next(iterator[, default])
+
+ Return the next item from the iterator. If default is given and the iterator
+ is exhausted, it is returned instead of raising StopIteration.
+ """
+ pass
+
+def oct(number): # real signature unknown; restored from __doc__
+ """
+ oct(number) -> string
+
+ Return the octal representation of an integer.
+
+ >>> oct(342391)
+ '0o1234567'
+ """
+ return ""
+
+def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
+ """
+ open(file, mode='r', buffering=-1, encoding=None,
+ errors=None, newline=None, closefd=True, opener=None) -> file object
+
+ Open file and return a stream. Raise IOError upon failure.
+
+ file is either a text or byte string giving the name (and the path
+ if the file isn't in the current working directory) of the file to
+ be opened or an integer file descriptor of the file to be
+ wrapped. (If a file descriptor is given, it is closed when the
+ returned I/O object is closed, unless closefd is set to False.)
+
+ mode is an optional string that specifies the mode in which the file
+ is opened. It defaults to 'r' which means open for reading in text
+ mode. Other common values are 'w' for writing (truncating the file if
+ it already exists), 'x' for creating and writing to a new file, and
+ 'a' for appending (which on some Unix systems, means that all writes
+ append to the end of the file regardless of the current seek position).
+ In text mode, if encoding is not specified the encoding used is platform
+ dependent: locale.getpreferredencoding(False) is called to get the
+ current locale encoding. (For reading and writing raw bytes use binary
+ mode and leave encoding unspecified.) The available modes are:
+
+ ========= ===============================================================
+ Character Meaning
+ --------- ---------------------------------------------------------------
+ 'r' open for reading (default)
+ 'w' open for writing, truncating the file first
+ 'x' create a new file and open it for writing
+ 'a' open for writing, appending to the end of the file if it exists
+ 'b' binary mode
+ 't' text mode (default)
+ '+' open a disk file for updating (reading and writing)
+ 'U' universal newline mode (deprecated)
+ ========= ===============================================================
+
+ The default mode is 'rt' (open for reading text). For binary random
+ access, the mode 'w+b' opens and truncates the file to 0 bytes, while
+ 'r+b' opens the file without truncation. The 'x' mode implies 'w' and
+ raises an `FileExistsError` if the file already exists.
+
+ Python distinguishes between files opened in binary and text modes,
+ even when the underlying operating system doesn't. Files opened in
+ binary mode (appending 'b' to the mode argument) return contents as
+ bytes objects without any decoding. In text mode (the default, or when
+ 't' is appended to the mode argument), the contents of the file are
+ returned as strings, the bytes having been first decoded using a
+ platform-dependent encoding or using the specified encoding if given.
+
+ 'U' mode is deprecated and will raise an exception in future versions
+ of Python. It has no effect in Python 3. Use newline to control
+ universal newlines mode.
+
+ buffering is an optional integer used to set the buffering policy.
+ Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
+ line buffering (only usable in text mode), and an integer > 1 to indicate
+ the size of a fixed-size chunk buffer. When no buffering argument is
+ given, the default buffering policy works as follows:
+
+ * Binary files are buffered in fixed-size chunks; the size of the buffer
+ is chosen using a heuristic trying to determine the underlying device's
+ "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
+ On many systems, the buffer will typically be 4096 or 8192 bytes long.
+
+ * "Interactive" text files (files for which isatty() returns True)
+ use line buffering. Other text files use the policy described above
+ for binary files.
+
+ encoding is the name of the encoding used to decode or encode the
+ file. This should only be used in text mode. The default encoding is
+ platform dependent, but any encoding supported by Python can be
+ passed. See the codecs module for the list of supported encodings.
+
+ errors is an optional string that specifies how encoding errors are to
+ be handled---this argument should not be used in binary mode. Pass
+ 'strict' to raise a ValueError exception if there is an encoding error
+ (the default of None has the same effect), or pass 'ignore' to ignore
+ errors. (Note that ignoring encoding errors can lead to data loss.)
+ See the documentation for codecs.register or run 'help(codecs.Codec)'
+ for a list of the permitted encoding error strings.
+
+ newline controls how universal newlines works (it only applies to text
+ mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
+ follows:
+
+ * On input, if newline is None, universal newlines mode is
+ enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
+ these are translated into '\n' before being returned to the
+ caller. If it is '', universal newline mode is enabled, but line
+ endings are returned to the caller untranslated. If it has any of
+ the other legal values, input lines are only terminated by the given
+ string, and the line ending is returned to the caller untranslated.
+
+ * On output, if newline is None, any '\n' characters written are
+ translated to the system default line separator, os.linesep. If
+ newline is '' or '\n', no translation takes place. If newline is any
+ of the other legal values, any '\n' characters written are translated
+ to the given string.
+
+ If closefd is False, the underlying file descriptor will be kept open
+ when the file is closed. This does not work when a file name is given
+ and must be True in that case.
+
+ A custom opener can be used by passing a callable as *opener*. The
+ underlying file descriptor for the file object is then obtained by
+ calling *opener* with (*file*, *flags*). *opener* must return an open
+ file descriptor (passing os.open as *opener* results in functionality
+ similar to passing None).
+
+ open() returns a file object whose type depends on the mode, and
+ through which the standard file operations such as reading and writing
+ are performed. When open() is used to open a file in a text mode ('w',
+ 'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
+ a file in a binary mode, the returned class varies: in read binary
+ mode, it returns a BufferedReader; in write binary and append binary
+ modes, it returns a BufferedWriter, and in read/write mode, it returns
+ a BufferedRandom.
+
+ It is also possible to use a string or bytearray as a file for both
+ reading and writing. For strings StringIO can be used like a file
+ opened in a text mode, and for bytes a BytesIO can be used like a file
+ opened in a binary mode.
+ """
+ pass
+
+def ord(c): # real signature unknown; restored from __doc__
+ """
+ ord(c) -> integer
+
+ Return the integer ordinal of a one-character string.
+ """
+ return 0
+
+def pow(x, y, z=None): # real signature unknown; restored from __doc__
+ """
+ pow(x, y[, z]) -> number
+
+ With two arguments, equivalent to x**y. With three arguments,
+ equivalent to (x**y) % z, but may be more efficient (e.g. for ints).
+ """
+ return 0
+
+def print(*args, sep=' ', end='\n', file=None): # known special case of print
+ """
+ print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
+
+ Prints the values to a stream, or to sys.stdout by default.
+ Optional keyword arguments:
+ file: a file-like object (stream); defaults to the current sys.stdout.
+ sep: string inserted between values, default a space.
+ end: string appended after the last value, default a newline.
+ flush: whether to forcibly flush the stream.
+ """
+ pass
+
+def quit(*args, **kwargs): # real signature unknown
+ pass
+
+def repr(p_object): # real signature unknown; restored from __doc__
+ """
+ repr(object) -> string
+
+ Return the canonical string representation of the object.
+ For most object types, eval(repr(object)) == object.
+ """
+ return ""
+
+def round(number, ndigits=None): # real signature unknown; restored from __doc__
+ """
+ round(number[, ndigits]) -> number
+
+ Round a number to a given precision in decimal digits (default 0 digits).
+ This returns an int when called with one argument, otherwise the
+ same type as the number. ndigits may be negative.
+ """
+ return 0
+
+def setattr(p_object, name, value): # real signature unknown; restored from __doc__
+ """
+ setattr(object, name, value)
+
+ Set a named attribute on an object; setattr(x, 'y', v) is equivalent to
+ ``x.y = v''.
+ """
+ pass
+
+def sorted(iterable, key=None, reverse=False): # real signature unknown; restored from __doc__
+ """ sorted(iterable, key=None, reverse=False) --> new sorted list """
+ pass
+
+def sum(iterable, start=None): # real signature unknown; restored from __doc__
+ """
+ sum(iterable[, start]) -> value
+
+ Return the sum of an iterable of numbers (NOT strings) plus the value
+ of parameter 'start' (which defaults to 0). When the iterable is
+ empty, return start.
+ """
+ pass
+
+def vars(p_object=None): # real signature unknown; restored from __doc__
+ """
+ vars([object]) -> dictionary
+
+ Without arguments, equivalent to locals().
+ With an argument, equivalent to object.__dict__.
+ """
+ return {}
+
+def __build_class__(func, name, *bases, metaclass=None, **kwds): # real signature unknown; restored from __doc__
+ """
+ __build_class__(func, name, *bases, metaclass=None, **kwds) -> class
+
+ Internal helper function used by the class statement.
+ """
+ pass
+
+def __import__(name, globals=None, locals=None, fromlist=(), level=0): # real signature unknown; restored from __doc__
+ """
+ __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
+
+ Import a module. Because this function is meant for use by the Python
+ interpreter and not for general use it is better to use
+ importlib.import_module() to programmatically import a module.
+
+ The globals argument is only used to determine the context;
+ they are not modified. The locals argument is unused. The fromlist
+ should be a list of names to emulate ``from name import ...'', or an
+ empty list to emulate ``import name''.
+ When importing a module from a package, note that __import__('A.B', ...)
+ returns package A when fromlist is empty, but its submodule B when
+ fromlist is not empty. Level is used to determine whether to perform
+ absolute or relative imports. 0 is absolute while a positive number
+ is the number of parent directories to search relative to the current module.
+ """
+ pass
+
+# classes
+
+
+class __generator(object):
+ '''A mock class representing the generator function type.'''
+ def __init__(self):
+ self.gi_code = None
+ self.gi_frame = None
+ self.gi_running = 0
+
+ def __iter__(self):
+ '''Defined to support iteration over container.'''
+ pass
+
+ def __next__(self):
+ '''Return the next item from the container.'''
+ pass
+
+ def close(self):
+ '''Raises new GeneratorExit exception inside the generator to terminate the iteration.'''
+ pass
+
+ def send(self, value):
+ '''Resumes the generator and "sends" a value that becomes the result of the current yield-expression.'''
+ pass
+
+ def throw(self, type, value=None, traceback=None):
+ '''Used to raise an exception inside the generator.'''
+ pass
+
+
+class __function(object):
+ '''A mock class representing function type.'''
+
+ def __init__(self):
+ self.__name__ = ''
+ self.__doc__ = ''
+ self.__dict__ = ''
+ self.__module__ = ''
+
+ self.__defaults__ = {}
+ self.__globals__ = {}
+ self.__closure__ = None
+ self.__code__ = None
+ self.__name__ = ''
+
+ self.__annotations__ = {}
+ self.__kwdefaults__ = {}
+
+ self.__qualname__ = ''
+
+
+class __method(object):
+ '''A mock class representing method type.'''
+
+ def __init__(self):
+
+ self.__func__ = None
+ self.__self__ = None
+
+
+class __namedtuple(tuple):
+ '''A mock base class for named tuples.'''
+
+ __slots__ = ()
+ _fields = ()
+
+ def __new__(cls, *args, **kwargs):
+ 'Create a new instance of the named tuple.'
+ return tuple.__new__(cls, *args)
+
+ @classmethod
+ def _make(cls, iterable, new=tuple.__new__, len=len):
+ 'Make a new named tuple object from a sequence or iterable.'
+ return new(cls, iterable)
+
+ def __repr__(self):
+ return ''
+
+ def _asdict(self):
+ 'Return a new dict which maps field types to their values.'
+ return {}
+
+ def _replace(self, **kwargs):
+ 'Return a new named tuple object replacing specified fields with new values.'
+ return self
+
+ def __getnewargs__(self):
+ return tuple(self)
+
+class object:
+ """ The most base type """
+ def __delattr__(self, *args, **kwargs): # real signature unknown
+ """ Implement delattr(self, name). """
+ pass
+
+ def __dir__(self): # real signature unknown; restored from __doc__
+ """
+ __dir__() -> list
+ default dir() implementation
+ """
+ return []
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __format__(self, *args, **kwargs): # real signature unknown
+ """ default object formatter """
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __hash__(self, *args, **kwargs): # real signature unknown
+ """ Return hash(self). """
+ pass
+
+ def __init__(self): # known special case of object.__init__
+ """ Initialize self. See help(type(self)) for accurate signature. """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(cls, *more): # known special case of object.__new__
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __reduce_ex__(self, *args, **kwargs): # real signature unknown
+ """ helper for pickle """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ """ helper for pickle """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __setattr__(self, *args, **kwargs): # real signature unknown
+ """ Implement setattr(self, name, value). """
+ pass
+
+ def __sizeof__(self): # real signature unknown; restored from __doc__
+ """
+ __sizeof__() -> int
+ size of object in memory, in bytes
+ """
+ return 0
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ @classmethod # known case
+ def __subclasshook__(cls, subclass): # known special case of object.__subclasshook__
+ """
+ Abstract classes can override this to customize issubclass().
+
+ This is invoked early on by abc.ABCMeta.__subclasscheck__().
+ It should return True, False or NotImplemented. If it returns
+ NotImplemented, the normal algorithm is used. Otherwise, it
+ overrides the normal algorithm (and the outcome is cached).
+ """
+ pass
+
+ __class__ = None # (!) forward: type, real value is ''
+ __dict__ = {}
+ __doc__ = ''
+ __module__ = ''
+
+
+from .object import object
+
+class BaseException(object):
+ """ Common base class for all exceptions """
+ def with_traceback(self, tb): # real signature unknown; restored from __doc__
+ """
+ Exception.with_traceback(tb) --
+ set self.__traceback__ to tb and return self.
+ """
+ pass
+
+ def __delattr__(self, *args, **kwargs): # real signature unknown
+ """ Implement delattr(self, name). """
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __setattr__(self, *args, **kwargs): # real signature unknown
+ """ Implement setattr(self, name, value). """
+ pass
+
+ def __setstate__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ args = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ __cause__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """exception cause"""
+
+ __context__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """exception context"""
+
+ __suppress_context__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ __traceback__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+ __dict__ = None # (!) real value is ''
+
+
+from .BaseException import BaseException
+
+class Exception(BaseException):
+ """ Common base class for all non-exit exceptions. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .Exception import Exception
+
+class ArithmeticError(Exception):
+ """ Base class for arithmetic errors. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .Exception import Exception
+
+class AssertionError(Exception):
+ """ Assertion failed. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .Exception import Exception
+
+class AttributeError(Exception):
+ """ Attribute not found. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .Exception import Exception
+
+class WindowsError(Exception):
+ """ Base class for I/O related errors. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ characters_written = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ errno = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """POSIX exception code"""
+
+ filename = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """exception filename"""
+
+ filename2 = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """second exception filename"""
+
+ strerror = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """exception strerror"""
+
+ winerror = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """Win32 exception code"""
+
+
+
+OSError = WindowsError
+
+
+IOError = WindowsError
+
+
+EnvironmentError = WindowsError
+
+
+from .OSError import OSError
+
+class BlockingIOError(OSError):
+ """ I/O operation would block. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .object import object
+
+class int(object):
+ """
+ int(x=0) -> integer
+ int(x, base=10) -> integer
+
+ Convert a number or string to an integer, or return 0 if no arguments
+ are given. If x is a number, return x.__int__(). For floating point
+ numbers, this truncates towards zero.
+
+ If x is not a number or if base is given, then x must be a string,
+ bytes, or bytearray instance representing an integer literal in the
+ given base. The literal can be preceded by '+' or '-' and be surrounded
+ by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
+ Base 0 means to interpret the base from the string as an integer literal.
+ >>> int('0b100', base=0)
+ 4
+ """
+ def bit_length(self): # real signature unknown; restored from __doc__
+ """
+ int.bit_length() -> int
+
+ Number of bits necessary to represent self in binary.
+ >>> bin(37)
+ '0b100101'
+ >>> (37).bit_length()
+ 6
+ """
+ return 0
+
+ def conjugate(self, *args, **kwargs): # real signature unknown
+ """ Returns self, the complex conjugate of any int. """
+ pass
+
+ @classmethod # known case
+ def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
+ """
+ int.from_bytes(bytes, byteorder, *, signed=False) -> int
+
+ Return the integer represented by the given array of bytes.
+
+ The bytes argument must either support the buffer protocol or be an
+ iterable object producing bytes. Bytes and bytearray are examples of
+ built-in objects that support the buffer protocol.
+
+ The byteorder argument determines the byte order used to represent the
+ integer. If byteorder is 'big', the most significant byte is at the
+ beginning of the byte array. If byteorder is 'little', the most
+ significant byte is at the end of the byte array. To request the native
+ byte order of the host system, use `sys.byteorder' as the byte order value.
+
+ The signed keyword-only argument indicates whether two's complement is
+ used to represent the integer.
+ """
+ pass
+
+ def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__
+ """
+ int.to_bytes(length, byteorder, *, signed=False) -> bytes
+
+ Return an array of bytes representing an integer.
+
+ The integer is represented using length bytes. An OverflowError is
+ raised if the integer is not representable with the given number of
+ bytes.
+
+ The byteorder argument determines the byte order used to represent the
+ integer. If byteorder is 'big', the most significant byte is at the
+ beginning of the byte array. If byteorder is 'little', the most
+ significant byte is at the end of the byte array. To request the native
+ byte order of the host system, use `sys.byteorder' as the byte order value.
+
+ The signed keyword-only argument determines whether two's complement is
+ used to represent the integer. If signed is False and a negative integer
+ is given, an OverflowError is raised.
+ """
+ pass
+
+ def __abs__(self, *args, **kwargs): # real signature unknown
+ """ abs(self) """
+ pass
+
+ def __add__(self, *args, **kwargs): # real signature unknown
+ """ Return self+value. """
+ pass
+
+ def __and__(self, *args, **kwargs): # real signature unknown
+ """ Return self&value. """
+ pass
+
+ def __bool__(self, *args, **kwargs): # real signature unknown
+ """ self != 0 """
+ pass
+
+ def __ceil__(self, *args, **kwargs): # real signature unknown
+ """ Ceiling of an Integral returns itself. """
+ pass
+
+ def __divmod__(self, *args, **kwargs): # real signature unknown
+ """ Return divmod(self, value). """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __float__(self, *args, **kwargs): # real signature unknown
+ """ float(self) """
+ pass
+
+ def __floordiv__(self, *args, **kwargs): # real signature unknown
+ """ Return self//value. """
+ pass
+
+ def __floor__(self, *args, **kwargs): # real signature unknown
+ """ Flooring an Integral returns itself. """
+ pass
+
+ def __format__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getnewargs__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __hash__(self, *args, **kwargs): # real signature unknown
+ """ Return hash(self). """
+ pass
+
+ def __index__(self, *args, **kwargs): # real signature unknown
+ """ Return self converted to an integer, if self is suitable for use as an index into a list. """
+ pass
+
+ def __init__(self, x, base=10): # known special case of int.__init__
+ """
+ int(x=0) -> integer
+ int(x, base=10) -> integer
+
+ Convert a number or string to an integer, or return 0 if no arguments
+ are given. If x is a number, return x.__int__(). For floating point
+ numbers, this truncates towards zero.
+
+ If x is not a number or if base is given, then x must be a string,
+ bytes, or bytearray instance representing an integer literal in the
+ given base. The literal can be preceded by '+' or '-' and be surrounded
+ by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
+ Base 0 means to interpret the base from the string as an integer literal.
+ >>> int('0b100', base=0)
+ 4
+ # (copied from class doc)
+ """
+ pass
+
+ def __int__(self, *args, **kwargs): # real signature unknown
+ """ int(self) """
+ pass
+
+ def __invert__(self, *args, **kwargs): # real signature unknown
+ """ ~self """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lshift__(self, *args, **kwargs): # real signature unknown
+ """ Return self<<value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ def __mod__(self, *args, **kwargs): # real signature unknown
+ """ Return self%value. """
+ pass
+
+ def __mul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value. """
+ pass
+
+ def __neg__(self, *args, **kwargs): # real signature unknown
+ """ -self """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __or__(self, *args, **kwargs): # real signature unknown
+ """ Return self|value. """
+ pass
+
+ def __pos__(self, *args, **kwargs): # real signature unknown
+ """ +self """
+ pass
+
+ def __pow__(self, *args, **kwargs): # real signature unknown
+ """ Return pow(self, value, mod). """
+ pass
+
+ def __radd__(self, *args, **kwargs): # real signature unknown
+ """ Return value+self. """
+ pass
+
+ def __rand__(self, *args, **kwargs): # real signature unknown
+ """ Return value&self. """
+ pass
+
+ def __rdivmod__(self, *args, **kwargs): # real signature unknown
+ """ Return divmod(value, self). """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __rfloordiv__(self, *args, **kwargs): # real signature unknown
+ """ Return value//self. """
+ pass
+
+ def __rlshift__(self, *args, **kwargs): # real signature unknown
+ """ Return value<<self. """
+ pass
+
+ def __rmod__(self, *args, **kwargs): # real signature unknown
+ """ Return value%self. """
+ pass
+
+ def __rmul__(self, *args, **kwargs): # real signature unknown
+ """ Return value*self. """
+ pass
+
+ def __ror__(self, *args, **kwargs): # real signature unknown
+ """ Return value|self. """
+ pass
+
+ def __round__(self, *args, **kwargs): # real signature unknown
+ """
+ Rounding an Integral returns itself.
+ Rounding with an ndigits argument also returns an integer.
+ """
+ pass
+
+ def __rpow__(self, *args, **kwargs): # real signature unknown
+ """ Return pow(value, self, mod). """
+ pass
+
+ def __rrshift__(self, *args, **kwargs): # real signature unknown
+ """ Return value>>self. """
+ pass
+
+ def __rshift__(self, *args, **kwargs): # real signature unknown
+ """ Return self>>value. """
+ pass
+
+ def __rsub__(self, *args, **kwargs): # real signature unknown
+ """ Return value-self. """
+ pass
+
+ def __rtruediv__(self, *args, **kwargs): # real signature unknown
+ """ Return value/self. """
+ pass
+
+ def __rxor__(self, *args, **kwargs): # real signature unknown
+ """ Return value^self. """
+ pass
+
+ def __sizeof__(self, *args, **kwargs): # real signature unknown
+ """ Returns size in memory, in bytes """
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ def __sub__(self, *args, **kwargs): # real signature unknown
+ """ Return self-value. """
+ pass
+
+ def __truediv__(self, *args, **kwargs): # real signature unknown
+ """ Return self/value. """
+ pass
+
+ def __trunc__(self, *args, **kwargs): # real signature unknown
+ """ Truncating an Integral returns itself. """
+ pass
+
+ def __xor__(self, *args, **kwargs): # real signature unknown
+ """ Return self^value. """
+ pass
+
+ denominator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """the denominator of a rational number in lowest terms"""
+
+ imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """the imaginary part of a complex number"""
+
+ numerator = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """the numerator of a rational number in lowest terms"""
+
+ real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """the real part of a complex number"""
+
+
+
+from .int import int
+
+class bool(int):
+ """
+ bool(x) -> bool
+
+ Returns True when the argument x is true, False otherwise.
+ The builtins True and False are the only two instances of the class bool.
+ The class bool is a subclass of the class int, and cannot be subclassed.
+ """
+ def __and__(self, *args, **kwargs): # real signature unknown
+ """ Return self&value. """
+ pass
+
+ def __init__(self, x): # real signature unknown; restored from __doc__
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __or__(self, *args, **kwargs): # real signature unknown
+ """ Return self|value. """
+ pass
+
+ def __rand__(self, *args, **kwargs): # real signature unknown
+ """ Return value&self. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __ror__(self, *args, **kwargs): # real signature unknown
+ """ Return value|self. """
+ pass
+
+ def __rxor__(self, *args, **kwargs): # real signature unknown
+ """ Return value^self. """
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ def __xor__(self, *args, **kwargs): # real signature unknown
+ """ Return self^value. """
+ pass
+
+
+from .OSError import OSError
+
+class ConnectionError(OSError):
+ """ Connection error. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .ConnectionError import ConnectionError
+
+class BrokenPipeError(ConnectionError):
+ """ Broken pipe. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .Exception import Exception
+
+class BufferError(Exception):
+ """ Buffer error. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .object import object
+
+class bytearray(object):
+ """
+ bytearray(iterable_of_ints) -> bytearray
+ bytearray(string, encoding[, errors]) -> bytearray
+ bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
+ bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
+ bytearray() -> empty bytes array
+
+ Construct an mutable bytearray object from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - a bytes or a buffer object
+ - any object implementing the buffer API.
+ - an integer
+ """
+ def append(self, p_int): # real signature unknown; restored from __doc__
+ """
+ B.append(int) -> None
+
+ Append a single item to the end of B.
+ """
+ pass
+
+ def capitalize(self): # real signature unknown; restored from __doc__
+ """
+ B.capitalize() -> copy of B
+
+ Return a copy of B with only its first character capitalized (ASCII)
+ and the rest lower-cased.
+ """
+ pass
+
+ def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
+ """
+ B.center(width[, fillchar]) -> copy of B
+
+ Return B centered in a string of length width. Padding is
+ done using the specified fill character (default is a space).
+ """
+ pass
+
+ def clear(self): # real signature unknown; restored from __doc__
+ """
+ B.clear() -> None
+
+ Remove all items from B.
+ """
+ pass
+
+ def copy(self): # real signature unknown; restored from __doc__
+ """
+ B.copy() -> bytearray
+
+ Return a copy of B.
+ """
+ return bytearray
+
+ def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.count(sub[, start[, end]]) -> int
+
+ Return the number of non-overlapping occurrences of subsection sub in
+ bytes B[start:end]. Optional arguments start and end are interpreted
+ as in slice notation.
+ """
+ return 0
+
+ def decode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
+ """
+ B.decode(encoding='utf-8', errors='strict') -> str
+
+ Decode B using the codec registered for encoding. Default encoding
+ is 'utf-8'. errors may be given to set a different error
+ handling scheme. Default is 'strict' meaning that encoding errors raise
+ a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
+ as well as any other name registered with codecs.register_error that is
+ able to handle UnicodeDecodeErrors.
+ """
+ return ""
+
+ def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.endswith(suffix[, start[, end]]) -> bool
+
+ Return True if B ends with the specified suffix, False otherwise.
+ With optional start, test B beginning at that position.
+ With optional end, stop comparing B at that position.
+ suffix can also be a tuple of bytes to try.
+ """
+ return False
+
+ def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
+ """
+ B.expandtabs(tabsize=8) -> copy of B
+
+ Return a copy of B where all tab characters are expanded using spaces.
+ If tabsize is not given, a tab size of 8 characters is assumed.
+ """
+ pass
+
+ def extend(self, iterable_of_ints): # real signature unknown; restored from __doc__
+ """
+ B.extend(iterable_of_ints) -> None
+
+ Append all the elements from the iterator or sequence to the
+ end of B.
+ """
+ pass
+
+ def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.find(sub[, start[, end]]) -> int
+
+ Return the lowest index in B where subsection sub is found,
+ such that sub is contained within B[start,end]. Optional
+ arguments start and end are interpreted as in slice notation.
+
+ Return -1 on failure.
+ """
+ return 0
+
+ @classmethod # known case
+ def fromhex(cls, string): # real signature unknown; restored from __doc__
+ """
+ bytearray.fromhex(string) -> bytearray (static method)
+
+ Create a bytearray object from a string of hexadecimal numbers.
+ Spaces between two numbers are accepted.
+ Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\xb9\x01\xef').
+ """
+ return bytearray
+
+ def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.index(sub[, start[, end]]) -> int
+
+ Like B.find() but raise ValueError when the subsection is not found.
+ """
+ return 0
+
+ def insert(self, index, p_int): # real signature unknown; restored from __doc__
+ """
+ B.insert(index, int) -> None
+
+ Insert a single item into the bytearray before the given index.
+ """
+ pass
+
+ def isalnum(self): # real signature unknown; restored from __doc__
+ """
+ B.isalnum() -> bool
+
+ Return True if all characters in B are alphanumeric
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def isalpha(self): # real signature unknown; restored from __doc__
+ """
+ B.isalpha() -> bool
+
+ Return True if all characters in B are alphabetic
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def isdigit(self): # real signature unknown; restored from __doc__
+ """
+ B.isdigit() -> bool
+
+ Return True if all characters in B are digits
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def islower(self): # real signature unknown; restored from __doc__
+ """
+ B.islower() -> bool
+
+ Return True if all cased characters in B are lowercase and there is
+ at least one cased character in B, False otherwise.
+ """
+ return False
+
+ def isspace(self): # real signature unknown; restored from __doc__
+ """
+ B.isspace() -> bool
+
+ Return True if all characters in B are whitespace
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def istitle(self): # real signature unknown; restored from __doc__
+ """
+ B.istitle() -> bool
+
+ Return True if B is a titlecased string and there is at least one
+ character in B, i.e. uppercase characters may only follow uncased
+ characters and lowercase characters only cased ones. Return False
+ otherwise.
+ """
+ return False
+
+ def isupper(self): # real signature unknown; restored from __doc__
+ """
+ B.isupper() -> bool
+
+ Return True if all cased characters in B are uppercase and there is
+ at least one cased character in B, False otherwise.
+ """
+ return False
+
+ def join(self, iterable_of_bytes): # real signature unknown; restored from __doc__
+ """
+ B.join(iterable_of_bytes) -> bytearray
+
+ Concatenate any number of bytes/bytearray objects, with B
+ in between each pair, and return the result as a new bytearray.
+ """
+ return bytearray
+
+ def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
+ """
+ B.ljust(width[, fillchar]) -> copy of B
+
+ Return B left justified in a string of length width. Padding is
+ done using the specified fill character (default is a space).
+ """
+ pass
+
+ def lower(self): # real signature unknown; restored from __doc__
+ """
+ B.lower() -> copy of B
+
+ Return a copy of B with all ASCII characters converted to lowercase.
+ """
+ pass
+
+ def lstrip(self, bytes=None): # real signature unknown; restored from __doc__
+ """
+ B.lstrip([bytes]) -> bytearray
+
+ Strip leading bytes contained in the argument
+ and return the result as a new bytearray.
+ If the argument is omitted, strip leading ASCII whitespace.
+ """
+ return bytearray
+
+ @staticmethod # known case
+ def maketrans(frm, to): # real signature unknown; restored from __doc__
+ """
+ B.maketrans(frm, to) -> translation table
+
+ Return a translation table (a bytes object of length 256) suitable
+ for use in the bytes or bytearray translate method where each byte
+ in frm is mapped to the byte at the same position in to.
+ The bytes objects frm and to must be of the same length.
+ """
+ pass
+
+ def partition(self, sep): # real signature unknown; restored from __doc__
+ """
+ B.partition(sep) -> (head, sep, tail)
+
+ Search for the separator sep in B, and return the part before it,
+ the separator itself, and the part after it. If the separator is not
+ found, returns B and two empty bytearray objects.
+ """
+ pass
+
+ def pop(self, index=None): # real signature unknown; restored from __doc__
+ """
+ B.pop([index]) -> int
+
+ Remove and return a single item from B. If no index
+ argument is given, will pop the last value.
+ """
+ return 0
+
+ def remove(self, p_int): # real signature unknown; restored from __doc__
+ """
+ B.remove(int) -> None
+
+ Remove the first occurrence of a value in B.
+ """
+ pass
+
+ def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
+ """
+ B.replace(old, new[, count]) -> bytearray
+
+ Return a copy of B with all occurrences of subsection
+ old replaced by new. If the optional argument count is
+ given, only the first count occurrences are replaced.
+ """
+ return bytearray
+
+ def reverse(self): # real signature unknown; restored from __doc__
+ """
+ B.reverse() -> None
+
+ Reverse the order of the values in B in place.
+ """
+ pass
+
+ def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.rfind(sub[, start[, end]]) -> int
+
+ Return the highest index in B where subsection sub is found,
+ such that sub is contained within B[start,end]. Optional
+ arguments start and end are interpreted as in slice notation.
+
+ Return -1 on failure.
+ """
+ return 0
+
+ def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.rindex(sub[, start[, end]]) -> int
+
+ Like B.rfind() but raise ValueError when the subsection is not found.
+ """
+ return 0
+
+ def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
+ """
+ B.rjust(width[, fillchar]) -> copy of B
+
+ Return B right justified in a string of length width. Padding is
+ done using the specified fill character (default is a space)
+ """
+ pass
+
+ def rpartition(self, sep): # real signature unknown; restored from __doc__
+ """
+ B.rpartition(sep) -> (head, sep, tail)
+
+ Search for the separator sep in B, starting at the end of B,
+ and return the part before it, the separator itself, and the
+ part after it. If the separator is not found, returns two empty
+ bytearray objects and B.
+ """
+ pass
+
+ def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
+ """
+ B.rsplit(sep=None, maxsplit=-1) -> list of bytearrays
+
+ Return a list of the sections in B, using sep as the delimiter,
+ starting at the end of B and working to the front.
+ If sep is not given, B is split on ASCII whitespace characters
+ (space, tab, return, newline, formfeed, vertical tab).
+ If maxsplit is given, at most maxsplit splits are done.
+ """
+ return []
+
+ def rstrip(self, bytes=None): # real signature unknown; restored from __doc__
+ """
+ B.rstrip([bytes]) -> bytearray
+
+ Strip trailing bytes contained in the argument
+ and return the result as a new bytearray.
+ If the argument is omitted, strip trailing ASCII whitespace.
+ """
+ return bytearray
+
+ def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
+ """
+ B.split(sep=None, maxsplit=-1) -> list of bytearrays
+
+ Return a list of the sections in B, using sep as the delimiter.
+ If sep is not given, B is split on ASCII whitespace characters
+ (space, tab, return, newline, formfeed, vertical tab).
+ If maxsplit is given, at most maxsplit splits are done.
+ """
+ return []
+
+ def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
+ """
+ B.splitlines([keepends]) -> list of lines
+
+ Return a list of the lines in B, breaking at line boundaries.
+ Line breaks are not included in the resulting list unless keepends
+ is given and true.
+ """
+ return []
+
+ def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.startswith(prefix[, start[, end]]) -> bool
+
+ Return True if B starts with the specified prefix, False otherwise.
+ With optional start, test B beginning at that position.
+ With optional end, stop comparing B at that position.
+ prefix can also be a tuple of bytes to try.
+ """
+ return False
+
+ def strip(self, bytes=None): # real signature unknown; restored from __doc__
+ """
+ B.strip([bytes]) -> bytearray
+
+ Strip leading and trailing bytes contained in the argument
+ and return the result as a new bytearray.
+ If the argument is omitted, strip ASCII whitespace.
+ """
+ return bytearray
+
+ def swapcase(self): # real signature unknown; restored from __doc__
+ """
+ B.swapcase() -> copy of B
+
+ Return a copy of B with uppercase ASCII characters converted
+ to lowercase ASCII and vice versa.
+ """
+ pass
+
+ def title(self): # real signature unknown; restored from __doc__
+ """
+ B.title() -> copy of B
+
+ Return a titlecased version of B, i.e. ASCII words start with uppercase
+ characters, all remaining cased characters have lowercase.
+ """
+ pass
+
+ def translate(self, table, deletechars=None): # real signature unknown; restored from __doc__
+ """
+ B.translate(table[, deletechars]) -> bytearray
+
+ Return a copy of B, where all characters occurring in the
+ optional argument deletechars are removed, and the remaining
+ characters have been mapped through the given translation
+ table, which must be a bytes object of length 256.
+ """
+ return bytearray
+
+ def upper(self): # real signature unknown; restored from __doc__
+ """
+ B.upper() -> copy of B
+
+ Return a copy of B with all ASCII characters converted to uppercase.
+ """
+ pass
+
+ def zfill(self, width): # real signature unknown; restored from __doc__
+ """
+ B.zfill(width) -> copy of B
+
+ Pad a numeric string B with zeros on the left, to fill a field
+ of the specified width. B is never truncated.
+ """
+ pass
+
+ def __add__(self, *args, **kwargs): # real signature unknown
+ """ Return self+value. """
+ pass
+
+ def __alloc__(self): # real signature unknown; restored from __doc__
+ """
+ B.__alloc__() -> int
+
+ Return the number of bytes actually allocated.
+ """
+ return 0
+
+ def __contains__(self, *args, **kwargs): # real signature unknown
+ """ Return key in self. """
+ pass
+
+ def __delitem__(self, *args, **kwargs): # real signature unknown
+ """ Delete self[key]. """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getitem__(self, *args, **kwargs): # real signature unknown
+ """ Return self[key]. """
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __iadd__(self, *args, **kwargs): # real signature unknown
+ """ Implement self+=value. """
+ pass
+
+ def __imul__(self, *args, **kwargs): # real signature unknown
+ """ Implement self*=value. """
+ pass
+
+ def __init__(self, source=None, encoding=None, errors='strict'): # known special case of bytearray.__init__
+ """
+ bytearray(iterable_of_ints) -> bytearray
+ bytearray(string, encoding[, errors]) -> bytearray
+ bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
+ bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
+ bytearray() -> empty bytes array
+
+ Construct an mutable bytearray object from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - a bytes or a buffer object
+ - any object implementing the buffer API.
+ - an integer
+ # (copied from class doc)
+ """
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ def __len__(self, *args, **kwargs): # real signature unknown
+ """ Return len(self). """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ def __mul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value.n """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __reduce_ex__(self, *args, **kwargs): # real signature unknown
+ """ Return state information for pickling. """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ """ Return state information for pickling. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __rmul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value. """
+ pass
+
+ def __setitem__(self, *args, **kwargs): # real signature unknown
+ """ Set self[key] to value. """
+ pass
+
+ def __sizeof__(self): # real signature unknown; restored from __doc__
+ """
+ B.__sizeof__() -> int
+
+ Returns the size of B in memory, in bytes
+ """
+ return 0
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ __hash__ = None
+
+
+from .object import object
+
+class bytes(object):
+ """
+ bytes(iterable_of_ints) -> bytes
+ bytes(string, encoding[, errors]) -> bytes
+ bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
+ bytes(int) -> bytes object of size given by the parameter initialized with null bytes
+ bytes() -> empty bytes object
+
+ Construct an immutable array of bytes from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - any object implementing the buffer API.
+ - an integer
+ """
+ def capitalize(self): # real signature unknown; restored from __doc__
+ """
+ B.capitalize() -> copy of B
+
+ Return a copy of B with only its first character capitalized (ASCII)
+ and the rest lower-cased.
+ """
+ pass
+
+ def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
+ """
+ B.center(width[, fillchar]) -> copy of B
+
+ Return B centered in a string of length width. Padding is
+ done using the specified fill character (default is a space).
+ """
+ pass
+
+ def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.count(sub[, start[, end]]) -> int
+
+ Return the number of non-overlapping occurrences of substring sub in
+ string B[start:end]. Optional arguments start and end are interpreted
+ as in slice notation.
+ """
+ return 0
+
+ def decode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
+ """
+ B.decode(encoding='utf-8', errors='strict') -> str
+
+ Decode B using the codec registered for encoding. Default encoding
+ is 'utf-8'. errors may be given to set a different error
+ handling scheme. Default is 'strict' meaning that encoding errors raise
+ a UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
+ as well as any other name registerd with codecs.register_error that is
+ able to handle UnicodeDecodeErrors.
+ """
+ return ""
+
+ def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.endswith(suffix[, start[, end]]) -> bool
+
+ Return True if B ends with the specified suffix, False otherwise.
+ With optional start, test B beginning at that position.
+ With optional end, stop comparing B at that position.
+ suffix can also be a tuple of bytes to try.
+ """
+ return False
+
+ def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
+ """
+ B.expandtabs(tabsize=8) -> copy of B
+
+ Return a copy of B where all tab characters are expanded using spaces.
+ If tabsize is not given, a tab size of 8 characters is assumed.
+ """
+ pass
+
+ def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.find(sub[, start[, end]]) -> int
+
+ Return the lowest index in B where substring sub is found,
+ such that sub is contained within B[start:end]. Optional
+ arguments start and end are interpreted as in slice notation.
+
+ Return -1 on failure.
+ """
+ return 0
+
+ @classmethod # known case
+ def fromhex(cls, string): # real signature unknown; restored from __doc__
+ """
+ bytes.fromhex(string) -> bytes
+
+ Create a bytes object from a string of hexadecimal numbers.
+ Spaces between two numbers are accepted.
+ Example: bytes.fromhex('B9 01EF') -> b'\xb9\x01\xef'.
+ """
+ return b""
+
+ def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.index(sub[, start[, end]]) -> int
+
+ Like B.find() but raise ValueError when the substring is not found.
+ """
+ return 0
+
+ def isalnum(self): # real signature unknown; restored from __doc__
+ """
+ B.isalnum() -> bool
+
+ Return True if all characters in B are alphanumeric
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def isalpha(self): # real signature unknown; restored from __doc__
+ """
+ B.isalpha() -> bool
+
+ Return True if all characters in B are alphabetic
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def isdigit(self): # real signature unknown; restored from __doc__
+ """
+ B.isdigit() -> bool
+
+ Return True if all characters in B are digits
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def islower(self): # real signature unknown; restored from __doc__
+ """
+ B.islower() -> bool
+
+ Return True if all cased characters in B are lowercase and there is
+ at least one cased character in B, False otherwise.
+ """
+ return False
+
+ def isspace(self): # real signature unknown; restored from __doc__
+ """
+ B.isspace() -> bool
+
+ Return True if all characters in B are whitespace
+ and there is at least one character in B, False otherwise.
+ """
+ return False
+
+ def istitle(self): # real signature unknown; restored from __doc__
+ """
+ B.istitle() -> bool
+
+ Return True if B is a titlecased string and there is at least one
+ character in B, i.e. uppercase characters may only follow uncased
+ characters and lowercase characters only cased ones. Return False
+ otherwise.
+ """
+ return False
+
+ def isupper(self): # real signature unknown; restored from __doc__
+ """
+ B.isupper() -> bool
+
+ Return True if all cased characters in B are uppercase and there is
+ at least one cased character in B, False otherwise.
+ """
+ return False
+
+ def join(self, iterable_of_bytes): # real signature unknown; restored from __doc__
+ """
+ B.join(iterable_of_bytes) -> bytes
+
+ Concatenate any number of bytes objects, with B in between each pair.
+ Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
+ """
+ return b""
+
+ def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
+ """
+ B.ljust(width[, fillchar]) -> copy of B
+
+ Return B left justified in a string of length width. Padding is
+ done using the specified fill character (default is a space).
+ """
+ pass
+
+ def lower(self): # real signature unknown; restored from __doc__
+ """
+ B.lower() -> copy of B
+
+ Return a copy of B with all ASCII characters converted to lowercase.
+ """
+ pass
+
+ def lstrip(self, bytes=None): # real signature unknown; restored from __doc__
+ """
+ B.lstrip([bytes]) -> bytes
+
+ Strip leading bytes contained in the argument.
+ If the argument is omitted, strip leading ASCII whitespace.
+ """
+ return b""
+
+ @staticmethod # known case
+ def maketrans(frm, to): # real signature unknown; restored from __doc__
+ """
+ B.maketrans(frm, to) -> translation table
+
+ Return a translation table (a bytes object of length 256) suitable
+ for use in the bytes or bytearray translate method where each byte
+ in frm is mapped to the byte at the same position in to.
+ The bytes objects frm and to must be of the same length.
+ """
+ pass
+
+ def partition(self, sep): # real signature unknown; restored from __doc__
+ """
+ B.partition(sep) -> (head, sep, tail)
+
+ Search for the separator sep in B, and return the part before it,
+ the separator itself, and the part after it. If the separator is not
+ found, returns B and two empty bytes objects.
+ """
+ pass
+
+ def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
+ """
+ B.replace(old, new[, count]) -> bytes
+
+ Return a copy of B with all occurrences of subsection
+ old replaced by new. If the optional argument count is
+ given, only first count occurances are replaced.
+ """
+ return b""
+
+ def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.rfind(sub[, start[, end]]) -> int
+
+ Return the highest index in B where substring sub is found,
+ such that sub is contained within B[start:end]. Optional
+ arguments start and end are interpreted as in slice notation.
+
+ Return -1 on failure.
+ """
+ return 0
+
+ def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.rindex(sub[, start[, end]]) -> int
+
+ Like B.rfind() but raise ValueError when the substring is not found.
+ """
+ return 0
+
+ def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
+ """
+ B.rjust(width[, fillchar]) -> copy of B
+
+ Return B right justified in a string of length width. Padding is
+ done using the specified fill character (default is a space)
+ """
+ pass
+
+ def rpartition(self, sep): # real signature unknown; restored from __doc__
+ """
+ B.rpartition(sep) -> (head, sep, tail)
+
+ Search for the separator sep in B, starting at the end of B,
+ and return the part before it, the separator itself, and the
+ part after it. If the separator is not found, returns two empty
+ bytes objects and B.
+ """
+ pass
+
+ def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
+ """
+ B.rsplit(sep=None, maxsplit=-1) -> list of bytes
+
+ Return a list of the sections in B, using sep as the delimiter,
+ starting at the end of B and working to the front.
+ If sep is not given, B is split on ASCII whitespace characters
+ (space, tab, return, newline, formfeed, vertical tab).
+ If maxsplit is given, at most maxsplit splits are done.
+ """
+ return []
+
+ def rstrip(self, bytes=None): # real signature unknown; restored from __doc__
+ """
+ B.rstrip([bytes]) -> bytes
+
+ Strip trailing bytes contained in the argument.
+ If the argument is omitted, strip trailing ASCII whitespace.
+ """
+ return b""
+
+ def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
+ """
+ B.split(sep=None, maxsplit=-1) -> list of bytes
+
+ Return a list of the sections in B, using sep as the delimiter.
+ If sep is not specified or is None, B is split on ASCII whitespace
+ characters (space, tab, return, newline, formfeed, vertical tab).
+ If maxsplit is given, at most maxsplit splits are done.
+ """
+ return []
+
+ def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
+ """
+ B.splitlines([keepends]) -> list of lines
+
+ Return a list of the lines in B, breaking at line boundaries.
+ Line breaks are not included in the resulting list unless keepends
+ is given and true.
+ """
+ return []
+
+ def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
+ """
+ B.startswith(prefix[, start[, end]]) -> bool
+
+ Return True if B starts with the specified prefix, False otherwise.
+ With optional start, test B beginning at that position.
+ With optional end, stop comparing B at that position.
+ prefix can also be a tuple of bytes to try.
+ """
+ return False
+
+ def strip(self, bytes=None): # real signature unknown; restored from __doc__
+ """
+ B.strip([bytes]) -> bytes
+
+ Strip leading and trailing bytes contained in the argument.
+ If the argument is omitted, strip leading and trailing ASCII whitespace.
+ """
+ return b""
+
+ def swapcase(self): # real signature unknown; restored from __doc__
+ """
+ B.swapcase() -> copy of B
+
+ Return a copy of B with uppercase ASCII characters converted
+ to lowercase ASCII and vice versa.
+ """
+ pass
+
+ def title(self): # real signature unknown; restored from __doc__
+ """
+ B.title() -> copy of B
+
+ Return a titlecased version of B, i.e. ASCII words start with uppercase
+ characters, all remaining cased characters have lowercase.
+ """
+ pass
+
+ def translate(self, table, deletechars=None): # real signature unknown; restored from __doc__
+ """
+ B.translate(table[, deletechars]) -> bytes
+
+ Return a copy of B, where all characters occurring in the
+ optional argument deletechars are removed, and the remaining
+ characters have been mapped through the given translation
+ table, which must be a bytes object of length 256.
+ """
+ return b""
+
+ def upper(self): # real signature unknown; restored from __doc__
+ """
+ B.upper() -> copy of B
+
+ Return a copy of B with all ASCII characters converted to uppercase.
+ """
+ pass
+
+ def zfill(self, width): # real signature unknown; restored from __doc__
+ """
+ B.zfill(width) -> copy of B
+
+ Pad a numeric string B with zeros on the left, to fill a field
+ of the specified width. B is never truncated.
+ """
+ pass
+
+ def __add__(self, *args, **kwargs): # real signature unknown
+ """ Return self+value. """
+ pass
+
+ def __contains__(self, *args, **kwargs): # real signature unknown
+ """ Return key in self. """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getitem__(self, *args, **kwargs): # real signature unknown
+ """ Return self[key]. """
+ pass
+
+ def __getnewargs__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __hash__(self, *args, **kwargs): # real signature unknown
+ """ Return hash(self). """
+ pass
+
+ def __init__(self, value=b'', encoding=None, errors='strict'): # known special case of bytes.__init__
+ """
+ bytes(iterable_of_ints) -> bytes
+ bytes(string, encoding[, errors]) -> bytes
+ bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
+ bytes(int) -> bytes object of size given by the parameter initialized with null bytes
+ bytes() -> empty bytes object
+
+ Construct an immutable array of bytes from:
+ - an iterable yielding integers in range(256)
+ - a text string encoded using the specified encoding
+ - any object implementing the buffer API.
+ - an integer
+ # (copied from class doc)
+ """
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ def __len__(self, *args, **kwargs): # real signature unknown
+ """ Return len(self). """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ def __mul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value.n """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __rmul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value. """
+ pass
+
+ def __sizeof__(self): # real signature unknown; restored from __doc__
+ """ B.__sizeof__() -> size of B in memory, in bytes """
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+
+from .Exception import Exception
+
+class Warning(Exception):
+ """ Base class for warning categories. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .Warning import Warning
+
+class BytesWarning(Warning):
+ """
+ Base class for warnings about bytes and buffer related problems, mostly
+ related to conversion from str or comparing to str.
+ """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .OSError import OSError
+
+class ChildProcessError(OSError):
+ """ Child process error. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .object import object
+
+class classmethod(object):
+ """
+ classmethod(function) -> method
+
+ Convert a function to be a class method.
+
+ A class method receives the class as implicit first argument,
+ just like an instance method receives the instance.
+ To declare a class method, use this idiom:
+
+ class C:
+ def f(cls, arg1, arg2, ...): ...
+ f = classmethod(f)
+
+ It can be called either on the class (e.g. C.f()) or on an instance
+ (e.g. C().f()). The instance is ignored except for its class.
+ If a class method is called for a derived class, the derived class
+ object is passed as the implied first argument.
+
+ Class methods are different than C++ or Java static methods.
+ If you want those, see the staticmethod builtin.
+ """
+ def __get__(self, *args, **kwargs): # real signature unknown
+ """ Return an attribute of instance, which is of type owner. """
+ pass
+
+ def __init__(self, function): # real signature unknown; restored from __doc__
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+ __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+
+
+ __dict__ = None # (!) real value is ''
+
+
+from .object import object
+
+class complex(object):
+ """
+ complex(real[, imag]) -> complex number
+
+ Create a complex number from a real part and an optional imaginary part.
+ This is equivalent to (real + imag*1j) where imag defaults to 0.
+ """
+ def conjugate(self): # real signature unknown; restored from __doc__
+ """
+ complex.conjugate() -> complex
+
+ Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
+ """
+ return complex
+
+ def __abs__(self, *args, **kwargs): # real signature unknown
+ """ abs(self) """
+ pass
+
+ def __add__(self, *args, **kwargs): # real signature unknown
+ """ Return self+value. """
+ pass
+
+ def __bool__(self, *args, **kwargs): # real signature unknown
+ """ self != 0 """
+ pass
+
+ def __divmod__(self, *args, **kwargs): # real signature unknown
+ """ Return divmod(self, value). """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __float__(self, *args, **kwargs): # real signature unknown
+ """ float(self) """
+ pass
+
+ def __floordiv__(self, *args, **kwargs): # real signature unknown
+ """ Return self//value. """
+ pass
+
+ def __format__(self): # real signature unknown; restored from __doc__
+ """
+ complex.__format__() -> str
+
+ Convert to a string according to format_spec.
+ """
+ return ""
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getnewargs__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __hash__(self, *args, **kwargs): # real signature unknown
+ """ Return hash(self). """
+ pass
+
+ def __init__(self, real, imag=None): # real signature unknown; restored from __doc__
+ pass
+
+ def __int__(self, *args, **kwargs): # real signature unknown
+ """ int(self) """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ def __mod__(self, *args, **kwargs): # real signature unknown
+ """ Return self%value. """
+ pass
+
+ def __mul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value. """
+ pass
+
+ def __neg__(self, *args, **kwargs): # real signature unknown
+ """ -self """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __pos__(self, *args, **kwargs): # real signature unknown
+ """ +self """
+ pass
+
+ def __pow__(self, *args, **kwargs): # real signature unknown
+ """ Return pow(self, value, mod). """
+ pass
+
+ def __radd__(self, *args, **kwargs): # real signature unknown
+ """ Return value+self. """
+ pass
+
+ def __rdivmod__(self, *args, **kwargs): # real signature unknown
+ """ Return divmod(value, self). """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __rfloordiv__(self, *args, **kwargs): # real signature unknown
+ """ Return value//self. """
+ pass
+
+ def __rmod__(self, *args, **kwargs): # real signature unknown
+ """ Return value%self. """
+ pass
+
+ def __rmul__(self, *args, **kwargs): # real signature unknown
+ """ Return value*self. """
+ pass
+
+ def __rpow__(self, *args, **kwargs): # real signature unknown
+ """ Return pow(value, self, mod). """
+ pass
+
+ def __rsub__(self, *args, **kwargs): # real signature unknown
+ """ Return value-self. """
+ pass
+
+ def __rtruediv__(self, *args, **kwargs): # real signature unknown
+ """ Return value/self. """
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ def __sub__(self, *args, **kwargs): # real signature unknown
+ """ Return self-value. """
+ pass
+
+ def __truediv__(self, *args, **kwargs): # real signature unknown
+ """ Return self/value. """
+ pass
+
+ imag = property(lambda self: 0.0)
+ """the imaginary part of a complex number
+
+ :type: float
+ """
+
+ real = property(lambda self: 0.0)
+ """the real part of a complex number
+
+ :type: float
+ """
+
+
+
+from .ConnectionError import ConnectionError
+
+class ConnectionAbortedError(ConnectionError):
+ """ Connection aborted. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .ConnectionError import ConnectionError
+
+class ConnectionRefusedError(ConnectionError):
+ """ Connection refused. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .ConnectionError import ConnectionError
+
+class ConnectionResetError(ConnectionError):
+ """ Connection reset. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .Warning import Warning
+
+class DeprecationWarning(Warning):
+ """ Base class for warnings about deprecated features. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .object import object
+
+class dict(object):
+ """
+ dict() -> new empty dictionary
+ dict(mapping) -> new dictionary initialized from a mapping object's
+ (key, value) pairs
+ dict(iterable) -> new dictionary initialized as if via:
+ d = {}
+ for k, v in iterable:
+ d[k] = v
+ dict(**kwargs) -> new dictionary initialized with the name=value pairs
+ in the keyword argument list. For example: dict(one=1, two=2)
+ """
+ def clear(self): # real signature unknown; restored from __doc__
+ """ D.clear() -> None. Remove all items from D. """
+ pass
+
+ def copy(self): # real signature unknown; restored from __doc__
+ """ D.copy() -> a shallow copy of D """
+ pass
+
+ @staticmethod # known case
+ def fromkeys(*args, **kwargs): # real signature unknown
+ """ Returns a new dict with keys from iterable and values equal to value. """
+ pass
+
+ def get(self, k, d=None): # real signature unknown; restored from __doc__
+ """ D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None. """
+ pass
+
+ def items(self): # real signature unknown; restored from __doc__
+ """ D.items() -> a set-like object providing a view on D's items """
+ pass
+
+ def keys(self): # real signature unknown; restored from __doc__
+ """ D.keys() -> a set-like object providing a view on D's keys """
+ pass
+
+ def pop(self, k, d=None): # real signature unknown; restored from __doc__
+ """
+ D.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
+ """
+ pass
+
+ def popitem(self): # real signature unknown; restored from __doc__
+ """
+ D.popitem() -> (k, v), remove and return some (key, value) pair as a
+ 2-tuple; but raise KeyError if D is empty.
+ """
+ pass
+
+ def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
+ """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
+ pass
+
+ def update(self, E=None, **F): # known special case of dict.update
+ """
+ D.update([E, ]**F) -> None. Update D from dict/iterable E and F.
+ If E is present and has a .keys() method, then does: for k in E: D[k] = E[k]
+ If E is present and lacks a .keys() method, then does: for k, v in E: D[k] = v
+ In either case, this is followed by: for k in F: D[k] = F[k]
+ """
+ pass
+
+ def values(self): # real signature unknown; restored from __doc__
+ """ D.values() -> an object providing a view on D's values """
+ pass
+
+ def __contains__(self, *args, **kwargs): # real signature unknown
+ """ True if D has a key k, else False. """
+ pass
+
+ def __delitem__(self, *args, **kwargs): # real signature unknown
+ """ Delete self[key]. """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getitem__(self, y): # real signature unknown; restored from __doc__
+ """ x.__getitem__(y) <==> x[y] """
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
+ """
+ dict() -> new empty dictionary
+ dict(mapping) -> new dictionary initialized from a mapping object's
+ (key, value) pairs
+ dict(iterable) -> new dictionary initialized as if via:
+ d = {}
+ for k, v in iterable:
+ d[k] = v
+ dict(**kwargs) -> new dictionary initialized with the name=value pairs
+ in the keyword argument list. For example: dict(one=1, two=2)
+ # (copied from class doc)
+ """
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ def __len__(self, *args, **kwargs): # real signature unknown
+ """ Return len(self). """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __setitem__(self, *args, **kwargs): # real signature unknown
+ """ Set self[key] to value. """
+ pass
+
+ def __sizeof__(self): # real signature unknown; restored from __doc__
+ """ D.__sizeof__() -> size of D in memory, in bytes """
+ pass
+
+ __hash__ = None
+
+
+from .object import object
+
+class enumerate(object):
+ """
+ enumerate(iterable[, start]) -> iterator for index, value of iterable
+
+ Return an enumerate object. iterable must be another object that supports
+ iteration. The enumerate object yields pairs containing a count (from
+ start, which defaults to zero) and a value yielded by the iterable argument.
+ enumerate is useful for obtaining an indexed list:
+ (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
+ """
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __init__(self, iterable, start=0): # known special case of enumerate.__init__
+ """ Initialize self. See help(type(self)) for accurate signature. """
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ """ Return state information for pickling. """
+ pass
+
+
+from .Exception import Exception
+
+class EOFError(Exception):
+ """ Read beyond end of file. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .OSError import OSError
+
+class FileExistsError(OSError):
+ """ File already exists. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .OSError import OSError
+
+class FileNotFoundError(OSError):
+ """ File not found. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+
+from .object import object
+
+class filter(object):
+ """
+ filter(function or None, iterable) --> filter object
+
+ Return an iterator yielding those items of iterable for which function(item)
+ is true. If function is None, return the items that are true.
+ """
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __init__(self, function_or_None, iterable): # real signature unknown; restored from __doc__
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __next__(self, *args, **kwargs): # real signature unknown
+ """ Implement next(self). """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ """ Return state information for pickling. """
+ pass
+
+
+from .object import object
+
+class float(object):
+ """
+ float(x) -> floating point number
+
+ Convert a string or number to a floating point number, if possible.
+ """
+ def as_integer_ratio(self): # real signature unknown; restored from __doc__
+ """
+ float.as_integer_ratio() -> (int, int)
+
+ Return a pair of integers, whose ratio is exactly equal to the original
+ float and with a positive denominator.
+ Raise OverflowError on infinities and a ValueError on NaNs.
+
+ >>> (10.0).as_integer_ratio()
+ (10, 1)
+ >>> (0.0).as_integer_ratio()
+ (0, 1)
+ >>> (-.25).as_integer_ratio()
+ (-1, 4)
+ """
+ pass
+
+ def conjugate(self, *args, **kwargs): # real signature unknown
+ """ Return self, the complex conjugate of any float. """
+ pass
+
+ def fromhex(self, string): # real signature unknown; restored from __doc__
+ """
+ float.fromhex(string) -> float
+
+ Create a floating-point number from a hexadecimal string.
+ >>> float.fromhex('0x1.ffffp10')
+ 2047.984375
+ >>> float.fromhex('-0x1p-1074')
+ -5e-324
+ """
+ return 0.0
+
+ def hex(self): # real signature unknown; restored from __doc__
+ """
+ float.hex() -> string
+
+ Return a hexadecimal representation of a floating-point number.
+ >>> (-0.1).hex()
+ '-0x1.999999999999ap-4'
+ >>> 3.14159.hex()
+ '0x1.921f9f01b866ep+1'
+ """
+ return ""
+
+ def is_integer(self, *args, **kwargs): # real signature unknown
+ """ Return True if the float is an integer. """
+ pass
+
+ def __abs__(self, *args, **kwargs): # real signature unknown
+ """ abs(self) """
+ pass
+
+ def __add__(self, *args, **kwargs): # real signature unknown
+ """ Return self+value. """
+ pass
+
+ def __bool__(self, *args, **kwargs): # real signature unknown
+ """ self != 0 """
+ pass
+
+ def __divmod__(self, *args, **kwargs): # real signature unknown
+ """ Return divmod(self, value). """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __float__(self, *args, **kwargs): # real signature unknown
+ """ float(self) """
+ pass
+
+ def __floordiv__(self, *args, **kwargs): # real signature unknown
+ """ Return self//value. """
+ pass
+
+ def __format__(self, format_spec): # real signature unknown; restored from __doc__
+ """
+ float.__format__(format_spec) -> string
+
+ Formats the float according to format_spec.
+ """
+ return ""
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __getformat__(self, typestr): # real signature unknown; restored from __doc__
+ """
+ float.__getformat__(typestr) -> string
+
+ You probably don't want to use this function. It exists mainly to be
+ used in Python's test suite.
+
+ typestr must be 'double' or 'float'. This function returns whichever of
+ 'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
+ format of floating point numbers used by the C type named by typestr.
+ """
+ return ""
+
+ def __getnewargs__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __hash__(self, *args, **kwargs): # real signature unknown
+ """ Return hash(self). """
+ pass
+
+ def __init__(self, x): # real signature unknown; restored from __doc__
+ pass
+
+ def __int__(self, *args, **kwargs): # real signature unknown
+ """ int(self) """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ def __mod__(self, *args, **kwargs): # real signature unknown
+ """ Return self%value. """
+ pass
+
+ def __mul__(self, *args, **kwargs): # real signature unknown
+ """ Return self*value. """
+ pass
+
+ def __neg__(self, *args, **kwargs): # real signature unknown
+ """ -self """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __pos__(self, *args, **kwargs): # real signature unknown
+ """ +self """
+ pass
+
+ def __pow__(self, *args, **kwargs): # real signature unknown
+ """ Return pow(self, value, mod). """
+ pass
+
+ def __radd__(self, *args, **kwargs): # real signature unknown
+ """ Return value+self. """
+ pass
+
+ def __rdivmod__(self, *args, **kwargs): # real signature unknown
+ """ Return divmod(value, self). """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __rfloordiv__(self, *args, **kwargs): # real signature unknown
+ """ Return value//self. """
+ pass
+
+ def __rmod__(self, *args, **kwargs): # real signature unknown
+ """ Return value%self. """
+ pass
+
+ def __rmul__(self, *args, **kwargs): # real signature unknown
+ """ Return value*self. """
+ pass
+
+ def __round__(self, *args, **kwargs): # real signature unknown
+ """
+ Return the Integral closest to x, rounding half toward even.
+ When an argument is passed, work like built-in round(x, ndigits).
+ """
+ pass
+
+ def __rpow__(self, *args, **kwargs): # real signature unknown
+ """ Return pow(value, self, mod). """
+ pass
+
+ def __rsub__(self, *args, **kwargs): # real signature unknown
+ """ Return value-self. """
+ pass
+
+ def __rtruediv__(self, *args, **kwargs): # real signature unknown
+ """ Return value/self. """
+ pass
+
+ def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__
+ """
+ float.__setformat__(typestr, fmt) -> None
+
+ You probably don't want to use this function. It exists mainly to be
+ used in Python's test suite.
+
+ typestr must be 'double' or 'float'. fmt must be one of 'unknown',
+ 'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
+ one of the latter two if it appears to match the underlying C reality.
+
+ Override the automatic determination of C-level floating point type.
+ This affects how floats are converted to and from binary strings.
+ """
+ pass
+
+ def __str__(self, *args, **kwargs): # real signature unknown
+ """ Return str(self). """
+ pass
+
+ def __sub__(self, *args, **kwargs): # real signature unknown
+ """ Return self-value. """
+ pass
+
+ def __truediv__(self, *args, **kwargs): # real signature unknown
+ """ Return self/value. """
+ pass
+
+ def __trunc__(self, *args, **kwargs): # real signature unknown
+ """ Return the Integral closest to x between 0 and x. """
+ pass
+
+ imag = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """the imaginary part of a complex number"""
+
+ real = property(lambda self: object(), lambda self, v: None, lambda self: None) # default
+ """the real part of a complex number"""
+
+
+
+from .ArithmeticError import ArithmeticError
+
+class FloatingPointError(ArithmeticError):
+ """ Floating point operation failed. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .object import object
+
+class frozenset(object):
+ """
+ frozenset() -> empty frozenset object
+ frozenset(iterable) -> frozenset object
+
+ Build an immutable unordered collection of unique elements.
+ """
+ def copy(self, *args, **kwargs): # real signature unknown
+ """ Return a shallow copy of a set. """
+ pass
+
+ def difference(self, *args, **kwargs): # real signature unknown
+ """
+ Return the difference of two or more sets as a new set.
+
+ (i.e. all elements that are in this set but not the others.)
+ """
+ pass
+
+ def intersection(self, *args, **kwargs): # real signature unknown
+ """
+ Return the intersection of two sets as a new set.
+
+ (i.e. all elements that are in both sets.)
+ """
+ pass
+
+ def isdisjoint(self, *args, **kwargs): # real signature unknown
+ """ Return True if two sets have a null intersection. """
+ pass
+
+ def issubset(self, *args, **kwargs): # real signature unknown
+ """ Report whether another set contains this set. """
+ pass
+
+ def issuperset(self, *args, **kwargs): # real signature unknown
+ """ Report whether this set contains another set. """
+ pass
+
+ def symmetric_difference(self, *args, **kwargs): # real signature unknown
+ """
+ Return the symmetric difference of two sets as a new set.
+
+ (i.e. all elements that are in exactly one of the sets.)
+ """
+ pass
+
+ def union(self, *args, **kwargs): # real signature unknown
+ """
+ Return the union of sets as a new set.
+
+ (i.e. all elements that are in either set.)
+ """
+ pass
+
+ def __and__(self, *args, **kwargs): # real signature unknown
+ """ Return self&value. """
+ pass
+
+ def __contains__(self, y): # real signature unknown; restored from __doc__
+ """ x.__contains__(y) <==> y in x. """
+ pass
+
+ def __eq__(self, *args, **kwargs): # real signature unknown
+ """ Return self==value. """
+ pass
+
+ def __getattribute__(self, *args, **kwargs): # real signature unknown
+ """ Return getattr(self, name). """
+ pass
+
+ def __ge__(self, *args, **kwargs): # real signature unknown
+ """ Return self>=value. """
+ pass
+
+ def __gt__(self, *args, **kwargs): # real signature unknown
+ """ Return self>value. """
+ pass
+
+ def __hash__(self, *args, **kwargs): # real signature unknown
+ """ Return hash(self). """
+ pass
+
+ def __init__(self, seq=()): # known special case of frozenset.__init__
+ """ Initialize self. See help(type(self)) for accurate signature. """
+ pass
+
+ def __iter__(self, *args, **kwargs): # real signature unknown
+ """ Implement iter(self). """
+ pass
+
+ def __len__(self, *args, **kwargs): # real signature unknown
+ """ Return len(self). """
+ pass
+
+ def __le__(self, *args, **kwargs): # real signature unknown
+ """ Return self<=value. """
+ pass
+
+ def __lt__(self, *args, **kwargs): # real signature unknown
+ """ Return self<value. """
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+ def __ne__(self, *args, **kwargs): # real signature unknown
+ """ Return self!=value. """
+ pass
+
+ def __or__(self, *args, **kwargs): # real signature unknown
+ """ Return self|value. """
+ pass
+
+ def __rand__(self, *args, **kwargs): # real signature unknown
+ """ Return value&self. """
+ pass
+
+ def __reduce__(self, *args, **kwargs): # real signature unknown
+ """ Return state information for pickling. """
+ pass
+
+ def __repr__(self, *args, **kwargs): # real signature unknown
+ """ Return repr(self). """
+ pass
+
+ def __ror__(self, *args, **kwargs): # real signature unknown
+ """ Return value|self. """
+ pass
+
+ def __rsub__(self, *args, **kwargs): # real signature unknown
+ """ Return value-self. """
+ pass
+
+ def __rxor__(self, *args, **kwargs): # real signature unknown
+ """ Return value^self. """
+ pass
+
+ def __sizeof__(self): # real signature unknown; restored from __doc__
+ """ S.__sizeof__() -> size of S in memory, in bytes """
+ pass
+
+ def __sub__(self, *args, **kwargs): # real signature unknown
+ """ Return self-value. """
+ pass
+
+ def __xor__(self, *args, **kwargs): # real signature unknown
+ """ Return self^value. """
+ pass
+
+
+from .Warning import Warning
+
+class FutureWarning(Warning):
+ """
+ Base class for warnings about constructs that will change semantically
+ in the future.
+ """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .BaseException import BaseException
+
+class GeneratorExit(BaseException):
+ """ Request that a generator exit. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ @staticmethod # known case of __new__
+ def __new__(*args, **kwargs): # real signature unknown
+ """ Create and return a new object. See help(type) for accurate signature. """
+ pass
+
+
+from .Exception import Exception
+
+class ImportError(Exception):
+ """ Import can't find module, or can't find name in module. """
+ def __init__(self, *args, **kwargs): # real signature unknown
+ pass
+
+ def __str__(self,&n
projects / idea / community.git / commitdiff