YsWEwPxT

1# encoding: utf-8
2# module builtins
3# from (built-in)
4# by generator 1.145
5"""
6Built-in functions, exceptions, and other objects.
7
8Noteworthy: None is the `nil' object; Ellipsis represents `...' in slices.
9"""
10# no imports
11
12# Variables with simple values
13# definition of False omitted
14# definition of None omitted
15# definition of True omitted
16# definition of __debug__ omitted
17
18# functions
19
20def abs(*args, **kwargs): # real signature unknown
21    """ Return the absolute value of the argument. """
22    pass
23
24def all(*args, **kwargs): # real signature unknown
25    """
26    Return True if bool(x) is True for all values x in the iterable.
27    
28    If the iterable is empty, return True.
29    """
30    pass
31
32def any(*args, **kwargs): # real signature unknown
33    """
34    Return True if bool(x) is True for any x in the iterable.
35    
36    If the iterable is empty, return False.
37    """
38    pass
39
40def ascii(*args, **kwargs): # real signature unknown
41    """
42    Return an ASCII-only representation of an object.
43    
44    As repr(), return a string containing a printable representation of an
45    object, but escape the non-ASCII characters in the string returned by
46    repr() using \\x, \\u or \\U escapes. This generates a string similar
47    to that returned by repr() in Python 2.
48    """
49    pass
50
51def bin(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
52    """
53    Return the binary representation of an integer.
54    
55       >>> bin(2796202)
56       '0b1010101010101010101010'
57    """
58    pass
59
60def callable(i_e_, some_kind_of_function): # real signature unknown; restored from __doc__
61    """
62    Return whether the object is callable (i.e., some kind of function).
63    
64    Note that classes are callable, as are instances of classes with a
65    __call__() method.
66    """
67    pass
68
69def chr(*args, **kwargs): # real signature unknown
70    """ Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff. """
71    pass
72
73def compile(*args, **kwargs): # real signature unknown
74    """
75    Compile source into a code object that can be executed by exec() or eval().
76    
77    The source code may represent a Python module, statement or expression.
78    The filename will be used for run-time error messages.
79    The mode must be 'exec' to compile a module, 'single' to compile a
80    single (interactive) statement, or 'eval' to compile an expression.
81    The flags argument, if present, controls which future statements influence
82    the compilation of the code.
83    The dont_inherit argument, if true, stops the compilation inheriting
84    the effects of any future statements in effect in the code calling
85    compile; if absent or false these statements do influence the compilation,
86    in addition to any features explicitly specified.
87    """
88    pass
89
90def copyright(*args, **kwargs): # real signature unknown
91    """
92    interactive prompt objects for printing the license text, a list of
93        contributors and the copyright notice.
94    """
95    pass
96
97def credits(*args, **kwargs): # real signature unknown
98    """
99    interactive prompt objects for printing the license text, a list of
100        contributors and the copyright notice.
101    """
102    pass
103
104def delattr(x, y): # real signature unknown; restored from __doc__
105    """
106    Deletes the named attribute from the given object.
107    
108    delattr(x, 'y') is equivalent to ``del x.y''
109    """
110    pass
111
112def dir(p_object=None): # real signature unknown; restored from __doc__
113    """
114    dir([object]) -> list of strings
115    
116    If called without an argument, return the names in the current scope.
117    Else, return an alphabetized list of names comprising (some of) the attributes
118    of the given object, and of attributes reachable from it.
119    If the object supplies a method named __dir__, it will be used; otherwise
120    the default dir() logic is used and returns:
121      for a module object: the module's attributes.
122      for a class object:  its attributes, and recursively the attributes
123        of its bases.
124      for any other object: its attributes, its class's attributes, and
125        recursively the attributes of its class's base classes.
126    """
127    return []
128
129def divmod(x, y): # known case of builtins.divmod
130    """ Return the tuple (x//y, x%y).  Invariant: div*y + mod == x. """
131    return (0, 0)
132
133def eval(*args, **kwargs): # real signature unknown
134    """
135    Evaluate the given source in the context of globals and locals.
136    
137    The source may be a string representing a Python expression
138    or a code object as returned by compile().
139    The globals must be a dictionary and locals can be any mapping,
140    defaulting to the current globals and locals.
141    If only globals is given, locals defaults to it.
142    """
143    pass
144
145def exec(*args, **kwargs): # real signature unknown
146    """
147    Execute the given source in the context of globals and locals.
148    
149    The source may be a string representing one or more Python statements
150    or a code object as returned by compile().
151    The globals must be a dictionary and locals can be any mapping,
152    defaulting to the current globals and locals.
153    If only globals is given, locals defaults to it.
154    """
155    pass
156
157def exit(*args, **kwargs): # real signature unknown
158    pass
159
160def format(*args, **kwargs): # real signature unknown
161    """
162    Return value.__format__(format_spec)
163    
164    format_spec defaults to the empty string.
165    See the Format Specification Mini-Language section of help('FORMATTING') for
166    details.
167    """
168    pass
169
170def getattr(object, name, default=None): # known special case of getattr
171    """
172    getattr(object, name[, default]) -> value
173    
174    Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
175    When a default argument is given, it is returned when the attribute doesn't
176    exist; without it, an exception is raised in that case.
177    """
178    pass
179
180def globals(*args, **kwargs): # real signature unknown
181    """
182    Return the dictionary containing the current scope's global variables.
183    
184    NOTE: Updates to this dictionary *will* affect name lookups in the current
185    global scope and vice-versa.
186    """
187    pass
188
189def hasattr(*args, **kwargs): # real signature unknown
190    """
191    Return whether the object has an attribute with the given name.
192    
193    This is done by calling getattr(obj, name) and catching AttributeError.
194    """
195    pass
196
197def hash(*args, **kwargs): # real signature unknown
198    """
199    Return the hash value for the given object.
200    
201    Two objects that compare equal must also have the same hash value, but the
202    reverse is not necessarily true.
203    """
204    pass
205
206def help(with_a_twist): # real signature unknown; restored from __doc__
207    """
208    Define the built-in 'help'.
209        This is a wrapper around pydoc.help (with a twist).
210    """
211    pass
212
213def hex(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
214    """
215    Return the hexadecimal representation of an integer.
216    
217       >>> hex(12648430)
218       '0xc0ffee'
219    """
220    pass
221
222def id(*args, **kwargs): # real signature unknown
223    """
224    Return the identity of an object.
225    
226    This is guaranteed to be unique among simultaneously existing objects.
227    (CPython uses the object's memory address.)
228    """
229    pass
230
231def input(*args, **kwargs): # real signature unknown
232    """
233    Read a string from standard input.  The trailing newline is stripped.
234    
235    The prompt string, if given, is printed to standard output without a
236    trailing newline before reading input.
237    
238    If the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.
239    On *nix systems, readline is used if available.
240    """
241    pass
242
243def isinstance(x, A_tuple): # real signature unknown; restored from __doc__
244    """
245    Return whether an object is an instance of a class or of a subclass thereof.
246    
247    A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
248    check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
249    or ...`` etc.
250    """
251    pass
252
253def issubclass(x, A_tuple): # real signature unknown; restored from __doc__
254    """
255    Return whether 'cls' is a derived from another class or is the same class.
256    
257    A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
258    check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
259    or ...`` etc.
260    """
261    pass
262
263def iter(source, sentinel=None): # known special case of iter
264    """
265    iter(iterable) -> iterator
266    iter(callable, sentinel) -> iterator
267    
268    Get an iterator from an object.  In the first form, the argument must
269    supply its own iterator, or be a sequence.
270    In the second form, the callable is called until it returns the sentinel.
271    """
272    pass
273
274def len(*args, **kwargs): # real signature unknown
275    """ Return the number of items in a container. """
276    pass
277
278def license(*args, **kwargs): # real signature unknown
279    """
280    interactive prompt objects for printing the license text, a list of
281        contributors and the copyright notice.
282    """
283    pass
284
285def locals(*args, **kwargs): # real signature unknown
286    """
287    Return a dictionary containing the current scope's local variables.
288    
289    NOTE: Whether or not updates to this dictionary will affect name lookups in
290    the local scope and vice-versa is *implementation dependent* and not
291    covered by any backwards compatibility guarantees.
292    """
293    pass
294
295def max(*args, key=None): # known special case of max
296    """
297    max(iterable, *[, default=obj, key=func]) -> value
298    max(arg1, arg2, *args, *[, key=func]) -> value
299    
300    With a single iterable argument, return its biggest item. The
301    default keyword-only argument specifies an object to return if
302    the provided iterable is empty.
303    With two or more arguments, return the largest argument.
304    """
305    pass
306
307def min(*args, key=None): # known special case of min
308    """
309    min(iterable, *[, default=obj, key=func]) -> value
310    min(arg1, arg2, *args, *[, key=func]) -> value
311    
312    With a single iterable argument, return its smallest item. The
313    default keyword-only argument specifies an object to return if
314    the provided iterable is empty.
315    With two or more arguments, return the smallest argument.
316    """
317    pass
318
319def next(iterator, default=None): # real signature unknown; restored from __doc__
320    """
321    next(iterator[, default])
322    
323    Return the next item from the iterator. If default is given and the iterator
324    is exhausted, it is returned instead of raising StopIteration.
325    """
326    pass
327
328def oct(*args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
329    """
330    Return the octal representation of an integer.
331    
332       >>> oct(342391)
333       '0o1234567'
334    """
335    pass
336
337def open(file, mode='r', buffering=None, encoding=None, errors=None, newline=None, closefd=True): # known special case of open
338    """
339    Open file and return a stream.  Raise IOError upon failure.
340    
341    file is either a text or byte string giving the name (and the path
342    if the file isn't in the current working directory) of the file to
343    be opened or an integer file descriptor of the file to be
344    wrapped. (If a file descriptor is given, it is closed when the
345    returned I/O object is closed, unless closefd is set to False.)
346    
347    mode is an optional string that specifies the mode in which the file
348    is opened. It defaults to 'r' which means open for reading in text
349    mode.  Other common values are 'w' for writing (truncating the file if
350    it already exists), 'x' for creating and writing to a new file, and
351    'a' for appending (which on some Unix systems, means that all writes
352    append to the end of the file regardless of the current seek position).
353    In text mode, if encoding is not specified the encoding used is platform
354    dependent: locale.getpreferredencoding(False) is called to get the
355    current locale encoding. (For reading and writing raw bytes use binary
356    mode and leave encoding unspecified.) The available modes are:
357    
358    ========= ===============================================================
359    Character Meaning
360    --------- ---------------------------------------------------------------
361    'r'       open for reading (default)
362    'w'       open for writing, truncating the file first
363    'x'       create a new file and open it for writing
364    'a'       open for writing, appending to the end of the file if it exists
365    'b'       binary mode
366    't'       text mode (default)
367    '+'       open a disk file for updating (reading and writing)
368    'U'       universal newline mode (deprecated)
369    ========= ===============================================================
370    
371    The default mode is 'rt' (open for reading text). For binary random
372    access, the mode 'w+b' opens and truncates the file to 0 bytes, while
373    'r+b' opens the file without truncation. The 'x' mode implies 'w' and
374    raises an `FileExistsError` if the file already exists.
375    
376    Python distinguishes between files opened in binary and text modes,
377    even when the underlying operating system doesn't. Files opened in
378    binary mode (appending 'b' to the mode argument) return contents as
379    bytes objects without any decoding. In text mode (the default, or when
380    't' is appended to the mode argument), the contents of the file are
381    returned as strings, the bytes having been first decoded using a
382    platform-dependent encoding or using the specified encoding if given.
383    
384    'U' mode is deprecated and will raise an exception in future versions
385    of Python.  It has no effect in Python 3.  Use newline to control
386    universal newlines mode.
387    
388    buffering is an optional integer used to set the buffering policy.
389    Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
390    line buffering (only usable in text mode), and an integer > 1 to indicate
391    the size of a fixed-size chunk buffer.  When no buffering argument is
392    given, the default buffering policy works as follows:
393    
394    * Binary files are buffered in fixed-size chunks; the size of the buffer
395      is chosen using a heuristic trying to determine the underlying device's
396      "block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
397      On many systems, the buffer will typically be 4096 or 8192 bytes long.
398    
399    * "Interactive" text files (files for which isatty() returns True)
400      use line buffering.  Other text files use the policy described above
401      for binary files.
402    
403    encoding is the name of the encoding used to decode or encode the
404    file. This should only be used in text mode. The default encoding is
405    platform dependent, but any encoding supported by Python can be
406    passed.  See the codecs module for the list of supported encodings.
407    
408    errors is an optional string that specifies how encoding errors are to
409    be handled---this argument should not be used in binary mode. Pass
410    'strict' to raise a ValueError exception if there is an encoding error
411    (the default of None has the same effect), or pass 'ignore' to ignore
412    errors. (Note that ignoring encoding errors can lead to data loss.)
413    See the documentation for codecs.register or run 'help(codecs.Codec)'
414    for a list of the permitted encoding error strings.
415    
416    newline controls how universal newlines works (it only applies to text
417    mode). It can be None, '', '\n', '\r', and '\r\n'.  It works as
418    follows:
419    
420    * On input, if newline is None, universal newlines mode is
421      enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
422      these are translated into '\n' before being returned to the
423      caller. If it is '', universal newline mode is enabled, but line
424      endings are returned to the caller untranslated. If it has any of
425      the other legal values, input lines are only terminated by the given
426      string, and the line ending is returned to the caller untranslated.
427    
428    * On output, if newline is None, any '\n' characters written are
429      translated to the system default line separator, os.linesep. If
430      newline is '' or '\n', no translation takes place. If newline is any
431      of the other legal values, any '\n' characters written are translated
432      to the given string.
433    
434    If closefd is False, the underlying file descriptor will be kept open
435    when the file is closed. This does not work when a file name is given
436    and must be True in that case.
437    
438    A custom opener can be used by passing a callable as *opener*. The
439    underlying file descriptor for the file object is then obtained by
440    calling *opener* with (*file*, *flags*). *opener* must return an open
441    file descriptor (passing os.open as *opener* results in functionality
442    similar to passing None).
443    
444    open() returns a file object whose type depends on the mode, and
445    through which the standard file operations such as reading and writing
446    are performed. When open() is used to open a file in a text mode ('w',
447    'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
448    a file in a binary mode, the returned class varies: in read binary
449    mode, it returns a BufferedReader; in write binary and append binary
450    modes, it returns a BufferedWriter, and in read/write mode, it returns
451    a BufferedRandom.
452    
453    It is also possible to use a string or bytearray as a file for both
454    reading and writing. For strings StringIO can be used like a file
455    opened in a text mode, and for bytes a BytesIO can be used like a file
456    opened in a binary mode.
457    """
458    pass
459
460def ord(*args, **kwargs): # real signature unknown
461    """ Return the Unicode code point for a one-character string. """
462    pass
463
464def pow(*args, **kwargs): # real signature unknown
465    """
466    Equivalent to x**y (with two arguments) or x**y % z (with three arguments)
467    
468    Some types, such as ints, are able to use a more efficient algorithm when
469    invoked using the three argument form.
470    """
471    pass
472
473def print(self, *args, sep=' ', end='\n', file=None): # known special case of print
474    """
475    print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
476    
477    Prints the values to a stream, or to sys.stdout by default.
478    Optional keyword arguments:
479    file:  a file-like object (stream); defaults to the current sys.stdout.
480    sep:   string inserted between values, default a space.
481    end:   string appended after the last value, default a newline.
482    flush: whether to forcibly flush the stream.
483    """
484    pass
485
486def quit(*args, **kwargs): # real signature unknown
487    pass
488
489def repr(obj): # real signature unknown; restored from __doc__
490    """
491    Return the canonical string representation of the object.
492    
493    For many object types, including most builtins, eval(repr(obj)) == obj.
494    """
495    pass
496
497def round(number, ndigits=None): # real signature unknown; restored from __doc__
498    """
499    round(number[, ndigits]) -> number
500    
501    Round a number to a given precision in decimal digits (default 0 digits).
502    This returns an int when called with one argument, otherwise the
503    same type as the number. ndigits may be negative.
504    """
505    return 0
506
507def setattr(x, y, v): # real signature unknown; restored from __doc__
508    """
509    Sets the named attribute on the given object to the specified value.
510    
511    setattr(x, 'y', v) is equivalent to ``x.y = v''
512    """
513    pass
514
515def sorted(*args, **kwargs): # real signature unknown
516    """
517    Return a new list containing all items from the iterable in ascending order.
518    
519    A custom key function can be supplied to customize the sort order, and the
520    reverse flag can be set to request the result in descending order.
521    """
522    pass
523
524def sum(*args, **kwargs): # real signature unknown
525    """
526    Return the sum of a 'start' value (default: 0) plus an iterable of numbers
527    
528    When the iterable is empty, return the start value.
529    This function is intended specifically for use with numeric values and may
530    reject non-numeric types.
531    """
532    pass
533
534def vars(p_object=None): # real signature unknown; restored from __doc__
535    """
536    vars([object]) -> dictionary
537    
538    Without arguments, equivalent to locals().
539    With an argument, equivalent to object.__dict__.
540    """
541    return {}
542
543def __build_class__(func, name, *bases, metaclass=None, **kwds): # real signature unknown; restored from __doc__
544    """
545    __build_class__(func, name, *bases, metaclass=None, **kwds) -> class
546    
547    Internal helper function used by the class statement.
548    """
549    pass
550
551def __import__(name, globals=None, locals=None, fromlist=(), level=0): # real signature unknown; restored from __doc__
552    """
553    __import__(name, globals=None, locals=None, fromlist=(), level=0) -> module
554    
555    Import a module. Because this function is meant for use by the Python
556    interpreter and not for general use it is better to use
557    importlib.import_module() to programmatically import a module.
558    
559    The globals argument is only used to determine the context;
560    they are not modified.  The locals argument is unused.  The fromlist
561    should be a list of names to emulate ``from name import ...'', or an
562    empty list to emulate ``import name''.
563    When importing a module from a package, note that __import__('A.B', ...)
564    returns package A when fromlist is empty, but its submodule B when
565    fromlist is not empty.  Level is used to determine whether to perform 
566    absolute or relative imports. 0 is absolute while a positive number
567    is the number of parent directories to search relative to the current module.
568    """
569    pass
570
571# classes
572
573
574class __generator(object):
575    '''A mock class representing the generator function type.'''
576    def __init__(self):
577        self.gi_code = None
578        self.gi_frame = None
579        self.gi_running = 0
580
581    def __iter__(self):
582        '''Defined to support iteration over container.'''
583        pass
584
585    def __next__(self):
586        '''Return the next item from the container.'''
587        pass
588
589    def close(self):
590        '''Raises new GeneratorExit exception inside the generator to terminate the iteration.'''
591        pass
592
593    def send(self, value):
594        '''Resumes the generator and "sends" a value that becomes the result of the current yield-expression.'''
595        pass
596
597    def throw(self, type, value=None, traceback=None):
598        '''Used to raise an exception inside the generator.'''
599        pass
600
601
602class __asyncgenerator(object):
603    '''A mock class representing the async generator function type.'''
604    def __init__(self):
605        '''Create an async generator object.'''
606        self.__name__ = ''
607        self.__qualname__ = ''
608        self.ag_await = None
609        self.ag_frame = None
610        self.ag_running = False
611        self.ag_code = None
612
613    def __aiter__(self):
614        '''Defined to support iteration over container.'''
615        pass
616
617    def __anext__(self):
618        '''Returns an awaitable, that performs one asynchronous generator iteration when awaited.'''
619        pass
620
621    def aclose(self):
622        '''Returns an awaitable, that throws a GeneratorExit exception into generator.'''
623        pass
624
625    def asend(self, value):
626        '''Returns an awaitable, that pushes the value object in generator.'''
627        pass
628
629    def athrow(self, type, value=None, traceback=None):
630        '''Returns an awaitable, that throws an exception into generator.'''
631        pass
632
633
634class __function(object):
635    '''A mock class representing function type.'''
636
637    def __init__(self):
638        self.__name__ = ''
639        self.__doc__ = ''
640        self.__dict__ = ''
641        self.__module__ = ''
642
643        self.__defaults__ = {}
644        self.__globals__ = {}
645        self.__closure__ = None
646        self.__code__ = None
647        self.__name__ = ''
648
649        self.__annotations__ = {}
650        self.__kwdefaults__ = {}
651
652        self.__qualname__ = ''
653
654
655class __method(object):
656    '''A mock class representing method type.'''
657
658    def __init__(self):
659
660        self.__func__ = None
661        self.__self__ = None
662
663
664class __coroutine(object):
665    '''A mock class representing coroutine type.'''
666
667    def __init__(self):
668        self.__name__ = ''
669        self.__qualname__ = ''
670        self.cr_await = None
671        self.cr_frame = None
672        self.cr_running = False
673        self.cr_code = None
674
675    def __await__(self):
676        return []
677
678    def close(self):
679        pass
680
681    def send(self, value):
682        pass
683
684    def throw(self, type, value=None, traceback=None):
685        pass
686
687
688class __namedtuple(tuple):
689    '''A mock base class for named tuples.'''
690
691    __slots__ = ()
692    _fields = ()
693
694    def __new__(cls, *args, **kwargs):
695        'Create a new instance of the named tuple.'
696        return tuple.__new__(cls, *args)
697
698    @classmethod
699    def _make(cls, iterable, new=tuple.__new__, len=len):
700        'Make a new named tuple object from a sequence or iterable.'
701        return new(cls, iterable)
702
703    def __repr__(self):
704        return ''
705
706    def _asdict(self):
707        'Return a new dict which maps field types to their values.'
708        return {}
709
710    def _replace(self, **kwargs):
711        'Return a new named tuple object replacing specified fields with new values.'
712        return self
713
714    def __getnewargs__(self):
715        return tuple(self)
716
717class object:
718    """ The most base type """
719    def __delattr__(self, *args, **kwargs): # real signature unknown
720        """ Implement delattr(self, name). """
721        pass
722
723    def __dir__(self): # real signature unknown; restored from __doc__
724        """
725        __dir__() -> list
726        default dir() implementation
727        """
728        return []
729
730    def __eq__(self, *args, **kwargs): # real signature unknown
731        """ Return self==value. """
732        pass
733
734    def __format__(self, *args, **kwargs): # real signature unknown
735        """ default object formatter """
736        pass
737
738    def __getattribute__(self, *args, **kwargs): # real signature unknown
739        """ Return getattr(self, name). """
740        pass
741
742    def __ge__(self, *args, **kwargs): # real signature unknown
743        """ Return self>=value. """
744        pass
745
746    def __gt__(self, *args, **kwargs): # real signature unknown
747        """ Return self>value. """
748        pass
749
750    def __hash__(self, *args, **kwargs): # real signature unknown
751        """ Return hash(self). """
752        pass
753
754    def __init_subclass__(self, *args, **kwargs): # real signature unknown
755        """
756        This method is called when a class is subclassed.
757        
758        The default implementation does nothing. It may be
759        overridden to extend subclasses.
760        """
761        pass
762
763    def __init__(self): # known special case of object.__init__
764        """ Initialize self.  See help(type(self)) for accurate signature. """
765        pass
766
767    def __le__(self, *args, **kwargs): # real signature unknown
768        """ Return self<=value. """
769        pass
770
771    def __lt__(self, *args, **kwargs): # real signature unknown
772        """ Return self<value. """
773        pass
774
775    @staticmethod # known case of __new__
776    def __new__(cls, *more): # known special case of object.__new__
777        """ Create and return a new object.  See help(type) for accurate signature. """
778        pass
779
780    def __ne__(self, *args, **kwargs): # real signature unknown
781        """ Return self!=value. """
782        pass
783
784    def __reduce_ex__(self, *args, **kwargs): # real signature unknown
785        """ helper for pickle """
786        pass
787
788    def __reduce__(self, *args, **kwargs): # real signature unknown
789        """ helper for pickle """
790        pass
791
792    def __repr__(self, *args, **kwargs): # real signature unknown
793        """ Return repr(self). """
794        pass
795
796    def __setattr__(self, *args, **kwargs): # real signature unknown
797        """ Implement setattr(self, name, value). """
798        pass
799
800    def __sizeof__(self): # real signature unknown; restored from __doc__
801        """
802        __sizeof__() -> int
803        size of object in memory, in bytes
804        """
805        return 0
806
807    def __str__(self, *args, **kwargs): # real signature unknown
808        """ Return str(self). """
809        pass
810
811    @classmethod # known case
812    def __subclasshook__(cls, subclass): # known special case of object.__subclasshook__
813        """
814        Abstract classes can override this to customize issubclass().
815        
816        This is invoked early on by abc.ABCMeta.__subclasscheck__().
817        It should return True, False or NotImplemented.  If it returns
818        NotImplemented, the normal algorithm is used.  Otherwise, it
819        overrides the normal algorithm (and the outcome is cached).
820        """
821        pass
822
823    __class__ = None # (!) forward: type, real value is ''
824    __dict__ = {}
825    __doc__ = ''
826    __module__ = ''
827
828
829class BaseException(object):
830    """ Common base class for all exceptions """
831    def with_traceback(self, tb): # real signature unknown; restored from __doc__
832        """
833        Exception.with_traceback(tb) --
834            set self.__traceback__ to tb and return self.
835        """
836        pass
837
838    def __delattr__(self, *args, **kwargs): # real signature unknown
839        """ Implement delattr(self, name). """
840        pass
841
842    def __getattribute__(self, *args, **kwargs): # real signature unknown
843        """ Return getattr(self, name). """
844        pass
845
846    def __init__(self, *args, **kwargs): # real signature unknown
847        pass
848
849    @staticmethod # known case of __new__
850    def __new__(*args, **kwargs): # real signature unknown
851        """ Create and return a new object.  See help(type) for accurate signature. """
852        pass
853
854    def __reduce__(self, *args, **kwargs): # real signature unknown
855        pass
856
857    def __repr__(self, *args, **kwargs): # real signature unknown
858        """ Return repr(self). """
859        pass
860
861    def __setattr__(self, *args, **kwargs): # real signature unknown
862        """ Implement setattr(self, name, value). """
863        pass
864
865    def __setstate__(self, *args, **kwargs): # real signature unknown
866        pass
867
868    def __str__(self, *args, **kwargs): # real signature unknown
869        """ Return str(self). """
870        pass
871
872    args = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
873
874    __cause__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
875    """exception cause"""
876
877    __context__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
878    """exception context"""
879
880    __suppress_context__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
881
882    __traceback__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
883
884
885    __dict__ = None # (!) real value is ''
886
887
888class Exception(BaseException):
889    """ Common base class for all non-exit exceptions. """
890    def __init__(self, *args, **kwargs): # real signature unknown
891        pass
892
893    @staticmethod # known case of __new__
894    def __new__(*args, **kwargs): # real signature unknown
895        """ Create and return a new object.  See help(type) for accurate signature. """
896        pass
897
898
899class ArithmeticError(Exception):
900    """ Base class for arithmetic errors. """
901    def __init__(self, *args, **kwargs): # real signature unknown
902        pass
903
904    @staticmethod # known case of __new__
905    def __new__(*args, **kwargs): # real signature unknown
906        """ Create and return a new object.  See help(type) for accurate signature. """
907        pass
908
909
910class AssertionError(Exception):
911    """ Assertion failed. """
912    def __init__(self, *args, **kwargs): # real signature unknown
913        pass
914
915    @staticmethod # known case of __new__
916    def __new__(*args, **kwargs): # real signature unknown
917        """ Create and return a new object.  See help(type) for accurate signature. """
918        pass
919
920
921class AttributeError(Exception):
922    """ Attribute not found. """
923    def __init__(self, *args, **kwargs): # real signature unknown
924        pass
925
926    @staticmethod # known case of __new__
927    def __new__(*args, **kwargs): # real signature unknown
928        """ Create and return a new object.  See help(type) for accurate signature. """
929        pass
930
931
932class OSError(Exception):
933    """ Base class for I/O related errors. """
934    def __init__(self, *args, **kwargs): # real signature unknown
935        pass
936
937    @staticmethod # known case of __new__
938    def __new__(*args, **kwargs): # real signature unknown
939        """ Create and return a new object.  See help(type) for accurate signature. """
940        pass
941
942    def __reduce__(self, *args, **kwargs): # real signature unknown
943        pass
944
945    def __str__(self, *args, **kwargs): # real signature unknown
946        """ Return str(self). """
947        pass
948
949    characters_written = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
950
951    errno = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
952    """POSIX exception code"""
953
954    filename = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
955    """exception filename"""
956
957    filename2 = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
958    """second exception filename"""
959
960    strerror = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
961    """exception strerror"""
962
963
964
965IOError = OSError
966
967
968EnvironmentError = OSError
969
970
971class BlockingIOError(OSError):
972    """ I/O operation would block. """
973    def __init__(self, *args, **kwargs): # real signature unknown
974        pass
975
976
977class int(object):
978    """
979    int(x=0) -> integer
980    int(x, base=10) -> integer
981    
982    Convert a number or string to an integer, or return 0 if no arguments
983    are given.  If x is a number, return x.__int__().  For floating point
984    numbers, this truncates towards zero.
985    
986    If x is not a number or if base is given, then x must be a string,
987    bytes, or bytearray instance representing an integer literal in the
988    given base.  The literal can be preceded by '+' or '-' and be surrounded
989    by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
990    Base 0 means to interpret the base from the string as an integer literal.
991    >>> int('0b100', base=0)
992    4
993    """
994    def bit_length(self): # real signature unknown; restored from __doc__
995        """
996        int.bit_length() -> int
997        
998        Number of bits necessary to represent self in binary.
999        >>> bin(37)
1000        '0b100101'
1001        >>> (37).bit_length()
1002        6
1003        """
1004        return 0
1005
1006    def conjugate(self, *args, **kwargs): # real signature unknown
1007        """ Returns self, the complex conjugate of any int. """
1008        pass
1009
1010    @classmethod # known case
1011    def from_bytes(cls, bytes, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
1012        """
1013        int.from_bytes(bytes, byteorder, *, signed=False) -> int
1014        
1015        Return the integer represented by the given array of bytes.
1016        
1017        The bytes argument must be a bytes-like object (e.g. bytes or bytearray).
1018        
1019        The byteorder argument determines the byte order used to represent the
1020        integer.  If byteorder is 'big', the most significant byte is at the
1021        beginning of the byte array.  If byteorder is 'little', the most
1022        significant byte is at the end of the byte array.  To request the native
1023        byte order of the host system, use `sys.byteorder' as the byte order value.
1024        
1025        The signed keyword-only argument indicates whether two's complement is
1026        used to represent the integer.
1027        """
1028        pass
1029
1030    def to_bytes(self, length, byteorder, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
1031        """
1032        int.to_bytes(length, byteorder, *, signed=False) -> bytes
1033        
1034        Return an array of bytes representing an integer.
1035        
1036        The integer is represented using length bytes.  An OverflowError is
1037        raised if the integer is not representable with the given number of
1038        bytes.
1039        
1040        The byteorder argument determines the byte order used to represent the
1041        integer.  If byteorder is 'big', the most significant byte is at the
1042        beginning of the byte array.  If byteorder is 'little', the most
1043        significant byte is at the end of the byte array.  To request the native
1044        byte order of the host system, use `sys.byteorder' as the byte order value.
1045        
1046        The signed keyword-only argument determines whether two's complement is
1047        used to represent the integer.  If signed is False and a negative integer
1048        is given, an OverflowError is raised.
1049        """
1050        pass
1051
1052    def __abs__(self, *args, **kwargs): # real signature unknown
1053        """ abs(self) """
1054        pass
1055
1056    def __add__(self, *args, **kwargs): # real signature unknown
1057        """ Return self+value. """
1058        pass
1059
1060    def __and__(self, *args, **kwargs): # real signature unknown
1061        """ Return self&value. """
1062        pass
1063
1064    def __bool__(self, *args, **kwargs): # real signature unknown
1065        """ self != 0 """
1066        pass
1067
1068    def __ceil__(self, *args, **kwargs): # real signature unknown
1069        """ Ceiling of an Integral returns itself. """
1070        pass
1071
1072    def __divmod__(self, *args, **kwargs): # real signature unknown
1073        """ Return divmod(self, value). """
1074        pass
1075
1076    def __eq__(self, *args, **kwargs): # real signature unknown
1077        """ Return self==value. """
1078        pass
1079
1080    def __float__(self, *args, **kwargs): # real signature unknown
1081        """ float(self) """
1082        pass
1083
1084    def __floordiv__(self, *args, **kwargs): # real signature unknown
1085        """ Return self//value. """
1086        pass
1087
1088    def __floor__(self, *args, **kwargs): # real signature unknown
1089        """ Flooring an Integral returns itself. """
1090        pass
1091
1092    def __format__(self, *args, **kwargs): # real signature unknown
1093        pass
1094
1095    def __getattribute__(self, *args, **kwargs): # real signature unknown
1096        """ Return getattr(self, name). """
1097        pass
1098
1099    def __getnewargs__(self, *args, **kwargs): # real signature unknown
1100        pass
1101
1102    def __ge__(self, *args, **kwargs): # real signature unknown
1103        """ Return self>=value. """
1104        pass
1105
1106    def __gt__(self, *args, **kwargs): # real signature unknown
1107        """ Return self>value. """
1108        pass
1109
1110    def __hash__(self, *args, **kwargs): # real signature unknown
1111        """ Return hash(self). """
1112        pass
1113
1114    def __index__(self, *args, **kwargs): # real signature unknown
1115        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
1116        pass
1117
1118    def __init__(self, x, base=10): # known special case of int.__init__
1119        """
1120        int(x=0) -> integer
1121        int(x, base=10) -> integer
1122        
1123        Convert a number or string to an integer, or return 0 if no arguments
1124        are given.  If x is a number, return x.__int__().  For floating point
1125        numbers, this truncates towards zero.
1126        
1127        If x is not a number or if base is given, then x must be a string,
1128        bytes, or bytearray instance representing an integer literal in the
1129        given base.  The literal can be preceded by '+' or '-' and be surrounded
1130        by whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.
1131        Base 0 means to interpret the base from the string as an integer literal.
1132        >>> int('0b100', base=0)
1133        4
1134        # (copied from class doc)
1135        """
1136        pass
1137
1138    def __int__(self, *args, **kwargs): # real signature unknown
1139        """ int(self) """
1140        pass
1141
1142    def __invert__(self, *args, **kwargs): # real signature unknown
1143        """ ~self """
1144        pass
1145
1146    def __le__(self, *args, **kwargs): # real signature unknown
1147        """ Return self<=value. """
1148        pass
1149
1150    def __lshift__(self, *args, **kwargs): # real signature unknown
1151        """ Return self<<value. """
1152        pass
1153
1154    def __lt__(self, *args, **kwargs): # real signature unknown
1155        """ Return self<value. """
1156        pass
1157
1158    def __mod__(self, *args, **kwargs): # real signature unknown
1159        """ Return self%value. """
1160        pass
1161
1162    def __mul__(self, *args, **kwargs): # real signature unknown
1163        """ Return self*value. """
1164        pass
1165
1166    def __neg__(self, *args, **kwargs): # real signature unknown
1167        """ -self """
1168        pass
1169
1170    @staticmethod # known case of __new__
1171    def __new__(*args, **kwargs): # real signature unknown
1172        """ Create and return a new object.  See help(type) for accurate signature. """
1173        pass
1174
1175    def __ne__(self, *args, **kwargs): # real signature unknown
1176        """ Return self!=value. """
1177        pass
1178
1179    def __or__(self, *args, **kwargs): # real signature unknown
1180        """ Return self|value. """
1181        pass
1182
1183    def __pos__(self, *args, **kwargs): # real signature unknown
1184        """ +self """
1185        pass
1186
1187    def __pow__(self, *args, **kwargs): # real signature unknown
1188        """ Return pow(self, value, mod). """
1189        pass
1190
1191    def __radd__(self, *args, **kwargs): # real signature unknown
1192        """ Return value+self. """
1193        pass
1194
1195    def __rand__(self, *args, **kwargs): # real signature unknown
1196        """ Return value&self. """
1197        pass
1198
1199    def __rdivmod__(self, *args, **kwargs): # real signature unknown
1200        """ Return divmod(value, self). """
1201        pass
1202
1203    def __repr__(self, *args, **kwargs): # real signature unknown
1204        """ Return repr(self). """
1205        pass
1206
1207    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
1208        """ Return value//self. """
1209        pass
1210
1211    def __rlshift__(self, *args, **kwargs): # real signature unknown
1212        """ Return value<<self. """
1213        pass
1214
1215    def __rmod__(self, *args, **kwargs): # real signature unknown
1216        """ Return value%self. """
1217        pass
1218
1219    def __rmul__(self, *args, **kwargs): # real signature unknown
1220        """ Return value*self. """
1221        pass
1222
1223    def __ror__(self, *args, **kwargs): # real signature unknown
1224        """ Return value|self. """
1225        pass
1226
1227    def __round__(self, *args, **kwargs): # real signature unknown
1228        """
1229        Rounding an Integral returns itself.
1230        Rounding with an ndigits argument also returns an integer.
1231        """
1232        pass
1233
1234    def __rpow__(self, *args, **kwargs): # real signature unknown
1235        """ Return pow(value, self, mod). """
1236        pass
1237
1238    def __rrshift__(self, *args, **kwargs): # real signature unknown
1239        """ Return value>>self. """
1240        pass
1241
1242    def __rshift__(self, *args, **kwargs): # real signature unknown
1243        """ Return self>>value. """
1244        pass
1245
1246    def __rsub__(self, *args, **kwargs): # real signature unknown
1247        """ Return value-self. """
1248        pass
1249
1250    def __rtruediv__(self, *args, **kwargs): # real signature unknown
1251        """ Return value/self. """
1252        pass
1253
1254    def __rxor__(self, *args, **kwargs): # real signature unknown
1255        """ Return value^self. """
1256        pass
1257
1258    def __sizeof__(self, *args, **kwargs): # real signature unknown
1259        """ Returns size in memory, in bytes """
1260        pass
1261
1262    def __str__(self, *args, **kwargs): # real signature unknown
1263        """ Return str(self). """
1264        pass
1265
1266    def __sub__(self, *args, **kwargs): # real signature unknown
1267        """ Return self-value. """
1268        pass
1269
1270    def __truediv__(self, *args, **kwargs): # real signature unknown
1271        """ Return self/value. """
1272        pass
1273
1274    def __trunc__(self, *args, **kwargs): # real signature unknown
1275        """ Truncating an Integral returns itself. """
1276        pass
1277
1278    def __xor__(self, *args, **kwargs): # real signature unknown
1279        """ Return self^value. """
1280        pass
1281
1282    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1283    """the denominator of a rational number in lowest terms"""
1284
1285    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1286    """the imaginary part of a complex number"""
1287
1288    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1289    """the numerator of a rational number in lowest terms"""
1290
1291    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1292    """the real part of a complex number"""
1293
1294
1295
1296class bool(int):
1297    """
1298    bool(x) -> bool
1299    
1300    Returns True when the argument x is true, False otherwise.
1301    The builtins True and False are the only two instances of the class bool.
1302    The class bool is a subclass of the class int, and cannot be subclassed.
1303    """
1304    def __and__(self, *args, **kwargs): # real signature unknown
1305        """ Return self&value. """
1306        pass
1307
1308    def __init__(self, x): # real signature unknown; restored from __doc__
1309        pass
1310
1311    @staticmethod # known case of __new__
1312    def __new__(*args, **kwargs): # real signature unknown
1313        """ Create and return a new object.  See help(type) for accurate signature. """
1314        pass
1315
1316    def __or__(self, *args, **kwargs): # real signature unknown
1317        """ Return self|value. """
1318        pass
1319
1320    def __rand__(self, *args, **kwargs): # real signature unknown
1321        """ Return value&self. """
1322        pass
1323
1324    def __repr__(self, *args, **kwargs): # real signature unknown
1325        """ Return repr(self). """
1326        pass
1327
1328    def __ror__(self, *args, **kwargs): # real signature unknown
1329        """ Return value|self. """
1330        pass
1331
1332    def __rxor__(self, *args, **kwargs): # real signature unknown
1333        """ Return value^self. """
1334        pass
1335
1336    def __str__(self, *args, **kwargs): # real signature unknown
1337        """ Return str(self). """
1338        pass
1339
1340    def __xor__(self, *args, **kwargs): # real signature unknown
1341        """ Return self^value. """
1342        pass
1343
1344
1345class ConnectionError(OSError):
1346    """ Connection error. """
1347    def __init__(self, *args, **kwargs): # real signature unknown
1348        pass
1349
1350
1351class BrokenPipeError(ConnectionError):
1352    """ Broken pipe. """
1353    def __init__(self, *args, **kwargs): # real signature unknown
1354        pass
1355
1356
1357class BufferError(Exception):
1358    """ Buffer error. """
1359    def __init__(self, *args, **kwargs): # real signature unknown
1360        pass
1361
1362    @staticmethod # known case of __new__
1363    def __new__(*args, **kwargs): # real signature unknown
1364        """ Create and return a new object.  See help(type) for accurate signature. """
1365        pass
1366
1367
1368class bytearray(object):
1369    """
1370    bytearray(iterable_of_ints) -> bytearray
1371    bytearray(string, encoding[, errors]) -> bytearray
1372    bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
1373    bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
1374    bytearray() -> empty bytes array
1375    
1376    Construct a mutable bytearray object from:
1377      - an iterable yielding integers in range(256)
1378      - a text string encoded using the specified encoding
1379      - a bytes or a buffer object
1380      - any object implementing the buffer API.
1381      - an integer
1382    """
1383    def append(self, *args, **kwargs): # real signature unknown
1384        """
1385        Append a single item to the end of the bytearray.
1386        
1387          item
1388            The item to be appended.
1389        """
1390        pass
1391
1392    def capitalize(self): # real signature unknown; restored from __doc__
1393        """
1394        B.capitalize() -> copy of B
1395        
1396        Return a copy of B with only its first character capitalized (ASCII)
1397        and the rest lower-cased.
1398        """
1399        pass
1400
1401    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
1402        """
1403        B.center(width[, fillchar]) -> copy of B
1404        
1405        Return B centered in a string of length width.  Padding is
1406        done using the specified fill character (default is a space).
1407        """
1408        pass
1409
1410    def clear(self, *args, **kwargs): # real signature unknown
1411        """ Remove all items from the bytearray. """
1412        pass
1413
1414    def copy(self, *args, **kwargs): # real signature unknown
1415        """ Return a copy of B. """
1416        pass
1417
1418    def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1419        """
1420        B.count(sub[, start[, end]]) -> int
1421        
1422        Return the number of non-overlapping occurrences of subsection sub in
1423        bytes B[start:end].  Optional arguments start and end are interpreted
1424        as in slice notation.
1425        """
1426        return 0
1427
1428    def decode(self, *args, **kwargs): # real signature unknown
1429        """
1430        Decode the bytearray using the codec registered for encoding.
1431        
1432          encoding
1433            The encoding with which to decode the bytearray.
1434          errors
1435            The error handling scheme to use for the handling of decoding errors.
1436            The default is 'strict' meaning that decoding errors raise a
1437            UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
1438            as well as any other name registered with codecs.register_error that
1439            can handle UnicodeDecodeErrors.
1440        """
1441        pass
1442
1443    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
1444        """
1445        B.endswith(suffix[, start[, end]]) -> bool
1446        
1447        Return True if B ends with the specified suffix, False otherwise.
1448        With optional start, test B beginning at that position.
1449        With optional end, stop comparing B at that position.
1450        suffix can also be a tuple of bytes to try.
1451        """
1452        return False
1453
1454    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
1455        """
1456        B.expandtabs(tabsize=8) -> copy of B
1457        
1458        Return a copy of B where all tab characters are expanded using spaces.
1459        If tabsize is not given, a tab size of 8 characters is assumed.
1460        """
1461        pass
1462
1463    def extend(self, *args, **kwargs): # real signature unknown
1464        """
1465        Append all the items from the iterator or sequence to the end of the bytearray.
1466        
1467          iterable_of_ints
1468            The iterable of items to append.
1469        """
1470        pass
1471
1472    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1473        """
1474        B.find(sub[, start[, end]]) -> int
1475        
1476        Return the lowest index in B where subsection sub is found,
1477        such that sub is contained within B[start,end].  Optional
1478        arguments start and end are interpreted as in slice notation.
1479        
1480        Return -1 on failure.
1481        """
1482        return 0
1483
1484    @classmethod # known case
1485    def fromhex(cls, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
1486        """
1487        Create a bytearray object from a string of hexadecimal numbers.
1488        
1489        Spaces between two numbers are accepted.
1490        Example: bytearray.fromhex('B9 01EF') -> bytearray(b'\\xb9\\x01\\xef')
1491        """
1492        pass
1493
1494    def hex(self): # real signature unknown; restored from __doc__
1495        """
1496        B.hex() -> string
1497        
1498        Create a string of hexadecimal numbers from a bytearray object.
1499        Example: bytearray([0xb9, 0x01, 0xef]).hex() -> 'b901ef'.
1500        """
1501        return ""
1502
1503    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1504        """
1505        B.index(sub[, start[, end]]) -> int
1506        
1507        Return the lowest index in B where subsection sub is found,
1508        such that sub is contained within B[start,end].  Optional
1509        arguments start and end are interpreted as in slice notation.
1510        
1511        Raises ValueError when the subsection is not found.
1512        """
1513        return 0
1514
1515    def insert(self, *args, **kwargs): # real signature unknown
1516        """
1517        Insert a single item into the bytearray before the given index.
1518        
1519          index
1520            The index where the value is to be inserted.
1521          item
1522            The item to be inserted.
1523        """
1524        pass
1525
1526    def isalnum(self): # real signature unknown; restored from __doc__
1527        """
1528        B.isalnum() -> bool
1529        
1530        Return True if all characters in B are alphanumeric
1531        and there is at least one character in B, False otherwise.
1532        """
1533        return False
1534
1535    def isalpha(self): # real signature unknown; restored from __doc__
1536        """
1537        B.isalpha() -> bool
1538        
1539        Return True if all characters in B are alphabetic
1540        and there is at least one character in B, False otherwise.
1541        """
1542        return False
1543
1544    def isdigit(self): # real signature unknown; restored from __doc__
1545        """
1546        B.isdigit() -> bool
1547        
1548        Return True if all characters in B are digits
1549        and there is at least one character in B, False otherwise.
1550        """
1551        return False
1552
1553    def islower(self): # real signature unknown; restored from __doc__
1554        """
1555        B.islower() -> bool
1556        
1557        Return True if all cased characters in B are lowercase and there is
1558        at least one cased character in B, False otherwise.
1559        """
1560        return False
1561
1562    def isspace(self): # real signature unknown; restored from __doc__
1563        """
1564        B.isspace() -> bool
1565        
1566        Return True if all characters in B are whitespace
1567        and there is at least one character in B, False otherwise.
1568        """
1569        return False
1570
1571    def istitle(self): # real signature unknown; restored from __doc__
1572        """
1573        B.istitle() -> bool
1574        
1575        Return True if B is a titlecased string and there is at least one
1576        character in B, i.e. uppercase characters may only follow uncased
1577        characters and lowercase characters only cased ones. Return False
1578        otherwise.
1579        """
1580        return False
1581
1582    def isupper(self): # real signature unknown; restored from __doc__
1583        """
1584        B.isupper() -> bool
1585        
1586        Return True if all cased characters in B are uppercase and there is
1587        at least one cased character in B, False otherwise.
1588        """
1589        return False
1590
1591    def join(self, *args, **kwargs): # real signature unknown
1592        """
1593        Concatenate any number of bytes/bytearray objects.
1594        
1595        The bytearray whose method is called is inserted in between each pair.
1596        
1597        The result is returned as a new bytearray object.
1598        """
1599        pass
1600
1601    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
1602        """
1603        B.ljust(width[, fillchar]) -> copy of B
1604        
1605        Return B left justified in a string of length width. Padding is
1606        done using the specified fill character (default is a space).
1607        """
1608        pass
1609
1610    def lower(self): # real signature unknown; restored from __doc__
1611        """
1612        B.lower() -> copy of B
1613        
1614        Return a copy of B with all ASCII characters converted to lowercase.
1615        """
1616        pass
1617
1618    def lstrip(self, *args, **kwargs): # real signature unknown
1619        """
1620        Strip leading bytes contained in the argument.
1621        
1622        If the argument is omitted or None, strip leading ASCII whitespace.
1623        """
1624        pass
1625
1626    @staticmethod # known case
1627    def maketrans(*args, **kwargs): # real signature unknown
1628        """
1629        Return a translation table useable for the bytes or bytearray translate method.
1630        
1631        The returned table will be one where each byte in frm is mapped to the byte at
1632        the same position in to.
1633        
1634        The bytes objects frm and to must be of the same length.
1635        """
1636        pass
1637
1638    def partition(self, *args, **kwargs): # real signature unknown
1639        """
1640        Partition the bytearray into three parts using the given separator.
1641        
1642        This will search for the separator sep in the bytearray. If the separator is
1643        found, returns a 3-tuple containing the part before the separator, the
1644        separator itself, and the part after it as new bytearray objects.
1645        
1646        If the separator is not found, returns a 3-tuple containing the copy of the
1647        original bytearray object and two empty bytearray objects.
1648        """
1649        pass
1650
1651    def pop(self, *args, **kwargs): # real signature unknown
1652        """
1653        Remove and return a single item from B.
1654        
1655          index
1656            The index from where to remove the item.
1657            -1 (the default value) means remove the last item.
1658        
1659        If no index argument is given, will pop the last item.
1660        """
1661        pass
1662
1663    def remove(self, *args, **kwargs): # real signature unknown
1664        """
1665        Remove the first occurrence of a value in the bytearray.
1666        
1667          value
1668            The value to remove.
1669        """
1670        pass
1671
1672    def replace(self, *args, **kwargs): # real signature unknown
1673        """
1674        Return a copy with all occurrences of substring old replaced by new.
1675        
1676          count
1677            Maximum number of occurrences to replace.
1678            -1 (the default value) means replace all occurrences.
1679        
1680        If the optional argument count is given, only the first count occurrences are
1681        replaced.
1682        """
1683        pass
1684
1685    def reverse(self, *args, **kwargs): # real signature unknown
1686        """ Reverse the order of the values in B in place. """
1687        pass
1688
1689    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1690        """
1691        B.rfind(sub[, start[, end]]) -> int
1692        
1693        Return the highest index in B where subsection sub is found,
1694        such that sub is contained within B[start,end].  Optional
1695        arguments start and end are interpreted as in slice notation.
1696        
1697        Return -1 on failure.
1698        """
1699        return 0
1700
1701    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
1702        """
1703        B.rindex(sub[, start[, end]]) -> int
1704        
1705        Return the highest index in B where subsection sub is found,
1706        such that sub is contained within B[start,end].  Optional
1707        arguments start and end are interpreted as in slice notation.
1708        
1709        Raise ValueError when the subsection is not found.
1710        """
1711        return 0
1712
1713    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
1714        """
1715        B.rjust(width[, fillchar]) -> copy of B
1716        
1717        Return B right justified in a string of length width. Padding is
1718        done using the specified fill character (default is a space)
1719        """
1720        pass
1721
1722    def rpartition(self, *args, **kwargs): # real signature unknown
1723        """
1724        Partition the bytearray into three parts using the given separator.
1725        
1726        This will search for the separator sep in the bytearray, starting at the end.
1727        If the separator is found, returns a 3-tuple containing the part before the
1728        separator, the separator itself, and the part after it as new bytearray
1729        objects.
1730        
1731        If the separator is not found, returns a 3-tuple containing two empty bytearray
1732        objects and the copy of the original bytearray object.
1733        """
1734        pass
1735
1736    def rsplit(self, *args, **kwargs): # real signature unknown
1737        """
1738        Return a list of the sections in the bytearray, using sep as the delimiter.
1739        
1740          sep
1741            The delimiter according which to split the bytearray.
1742            None (the default value) means split on ASCII whitespace characters
1743            (space, tab, return, newline, formfeed, vertical tab).
1744          maxsplit
1745            Maximum number of splits to do.
1746            -1 (the default value) means no limit.
1747        
1748        Splitting is done starting at the end of the bytearray and working to the front.
1749        """
1750        pass
1751
1752    def rstrip(self, *args, **kwargs): # real signature unknown
1753        """
1754        Strip trailing bytes contained in the argument.
1755        
1756        If the argument is omitted or None, strip trailing ASCII whitespace.
1757        """
1758        pass
1759
1760    def split(self, *args, **kwargs): # real signature unknown
1761        """
1762        Return a list of the sections in the bytearray, using sep as the delimiter.
1763        
1764          sep
1765            The delimiter according which to split the bytearray.
1766            None (the default value) means split on ASCII whitespace characters
1767            (space, tab, return, newline, formfeed, vertical tab).
1768          maxsplit
1769            Maximum number of splits to do.
1770            -1 (the default value) means no limit.
1771        """
1772        pass
1773
1774    def splitlines(self, *args, **kwargs): # real signature unknown
1775        """
1776        Return a list of the lines in the bytearray, breaking at line boundaries.
1777        
1778        Line breaks are not included in the resulting list unless keepends is given and
1779        true.
1780        """
1781        pass
1782
1783    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
1784        """
1785        B.startswith(prefix[, start[, end]]) -> bool
1786        
1787        Return True if B starts with the specified prefix, False otherwise.
1788        With optional start, test B beginning at that position.
1789        With optional end, stop comparing B at that position.
1790        prefix can also be a tuple of bytes to try.
1791        """
1792        return False
1793
1794    def strip(self, *args, **kwargs): # real signature unknown
1795        """
1796        Strip leading and trailing bytes contained in the argument.
1797        
1798        If the argument is omitted or None, strip leading and trailing ASCII whitespace.
1799        """
1800        pass
1801
1802    def swapcase(self): # real signature unknown; restored from __doc__
1803        """
1804        B.swapcase() -> copy of B
1805        
1806        Return a copy of B with uppercase ASCII characters converted
1807        to lowercase ASCII and vice versa.
1808        """
1809        pass
1810
1811    def title(self): # real signature unknown; restored from __doc__
1812        """
1813        B.title() -> copy of B
1814        
1815        Return a titlecased version of B, i.e. ASCII words start with uppercase
1816        characters, all remaining cased characters have lowercase.
1817        """
1818        pass
1819
1820    def translate(self, *args, **kwargs): # real signature unknown
1821        """
1822        Return a copy with each character mapped by the given translation table.
1823        
1824          table
1825            Translation table, which must be a bytes object of length 256.
1826        
1827        All characters occurring in the optional argument delete are removed.
1828        The remaining characters are mapped through the given translation table.
1829        """
1830        pass
1831
1832    def upper(self): # real signature unknown; restored from __doc__
1833        """
1834        B.upper() -> copy of B
1835        
1836        Return a copy of B with all ASCII characters converted to uppercase.
1837        """
1838        pass
1839
1840    def zfill(self, width): # real signature unknown; restored from __doc__
1841        """
1842        B.zfill(width) -> copy of B
1843        
1844        Pad a numeric string B with zeros on the left, to fill a field
1845        of the specified width.  B is never truncated.
1846        """
1847        pass
1848
1849    def __add__(self, *args, **kwargs): # real signature unknown
1850        """ Return self+value. """
1851        pass
1852
1853    def __alloc__(self): # real signature unknown; restored from __doc__
1854        """
1855        B.__alloc__() -> int
1856        
1857        Return the number of bytes actually allocated.
1858        """
1859        return 0
1860
1861    def __contains__(self, *args, **kwargs): # real signature unknown
1862        """ Return key in self. """
1863        pass
1864
1865    def __delitem__(self, *args, **kwargs): # real signature unknown
1866        """ Delete self[key]. """
1867        pass
1868
1869    def __eq__(self, *args, **kwargs): # real signature unknown
1870        """ Return self==value. """
1871        pass
1872
1873    def __getattribute__(self, *args, **kwargs): # real signature unknown
1874        """ Return getattr(self, name). """
1875        pass
1876
1877    def __getitem__(self, *args, **kwargs): # real signature unknown
1878        """ Return self[key]. """
1879        pass
1880
1881    def __ge__(self, *args, **kwargs): # real signature unknown
1882        """ Return self>=value. """
1883        pass
1884
1885    def __gt__(self, *args, **kwargs): # real signature unknown
1886        """ Return self>value. """
1887        pass
1888
1889    def __iadd__(self, *args, **kwargs): # real signature unknown
1890        """ Implement self+=value. """
1891        pass
1892
1893    def __imul__(self, *args, **kwargs): # real signature unknown
1894        """ Implement self*=value. """
1895        pass
1896
1897    def __init__(self, source=None, encoding=None, errors='strict'): # known special case of bytearray.__init__
1898        """
1899        bytearray(iterable_of_ints) -> bytearray
1900        bytearray(string, encoding[, errors]) -> bytearray
1901        bytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer
1902        bytearray(int) -> bytes array of size given by the parameter initialized with null bytes
1903        bytearray() -> empty bytes array
1904        
1905        Construct a mutable bytearray object from:
1906          - an iterable yielding integers in range(256)
1907          - a text string encoded using the specified encoding
1908          - a bytes or a buffer object
1909          - any object implementing the buffer API.
1910          - an integer
1911        # (copied from class doc)
1912        """
1913        pass
1914
1915    def __iter__(self, *args, **kwargs): # real signature unknown
1916        """ Implement iter(self). """
1917        pass
1918
1919    def __len__(self, *args, **kwargs): # real signature unknown
1920        """ Return len(self). """
1921        pass
1922
1923    def __le__(self, *args, **kwargs): # real signature unknown
1924        """ Return self<=value. """
1925        pass
1926
1927    def __lt__(self, *args, **kwargs): # real signature unknown
1928        """ Return self<value. """
1929        pass
1930
1931    def __mod__(self, *args, **kwargs): # real signature unknown
1932        """ Return self%value. """
1933        pass
1934
1935    def __mul__(self, *args, **kwargs): # real signature unknown
1936        """ Return self*value.n """
1937        pass
1938
1939    @staticmethod # known case of __new__
1940    def __new__(*args, **kwargs): # real signature unknown
1941        """ Create and return a new object.  See help(type) for accurate signature. """
1942        pass
1943
1944    def __ne__(self, *args, **kwargs): # real signature unknown
1945        """ Return self!=value. """
1946        pass
1947
1948    def __reduce_ex__(self, *args, **kwargs): # real signature unknown
1949        """ Return state information for pickling. """
1950        pass
1951
1952    def __reduce__(self, *args, **kwargs): # real signature unknown
1953        """ Return state information for pickling. """
1954        pass
1955
1956    def __repr__(self, *args, **kwargs): # real signature unknown
1957        """ Return repr(self). """
1958        pass
1959
1960    def __rmod__(self, *args, **kwargs): # real signature unknown
1961        """ Return value%self. """
1962        pass
1963
1964    def __rmul__(self, *args, **kwargs): # real signature unknown
1965        """ Return self*value. """
1966        pass
1967
1968    def __setitem__(self, *args, **kwargs): # real signature unknown
1969        """ Set self[key] to value. """
1970        pass
1971
1972    def __sizeof__(self, *args, **kwargs): # real signature unknown
1973        """ Returns the size of the bytearray object in memory, in bytes. """
1974        pass
1975
1976    def __str__(self, *args, **kwargs): # real signature unknown
1977        """ Return str(self). """
1978        pass
1979
1980    __hash__ = None
1981
1982
1983class bytes(object):
1984    """
1985    bytes(iterable_of_ints) -> bytes
1986    bytes(string, encoding[, errors]) -> bytes
1987    bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
1988    bytes(int) -> bytes object of size given by the parameter initialized with null bytes
1989    bytes() -> empty bytes object
1990    
1991    Construct an immutable array of bytes from:
1992      - an iterable yielding integers in range(256)
1993      - a text string encoded using the specified encoding
1994      - any object implementing the buffer API.
1995      - an integer
1996    """
1997    def capitalize(self): # real signature unknown; restored from __doc__
1998        """
1999        B.capitalize() -> copy of B
2000        
2001        Return a copy of B with only its first character capitalized (ASCII)
2002        and the rest lower-cased.
2003        """
2004        pass
2005
2006    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
2007        """
2008        B.center(width[, fillchar]) -> copy of B
2009        
2010        Return B centered in a string of length width.  Padding is
2011        done using the specified fill character (default is a space).
2012        """
2013        pass
2014
2015    def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2016        """
2017        B.count(sub[, start[, end]]) -> int
2018        
2019        Return the number of non-overlapping occurrences of subsection sub in
2020        bytes B[start:end].  Optional arguments start and end are interpreted
2021        as in slice notation.
2022        """
2023        return 0
2024
2025    def decode(self, *args, **kwargs): # real signature unknown
2026        """
2027        Decode the bytes using the codec registered for encoding.
2028        
2029          encoding
2030            The encoding with which to decode the bytes.
2031          errors
2032            The error handling scheme to use for the handling of decoding errors.
2033            The default is 'strict' meaning that decoding errors raise a
2034            UnicodeDecodeError. Other possible values are 'ignore' and 'replace'
2035            as well as any other name registered with codecs.register_error that
2036            can handle UnicodeDecodeErrors.
2037        """
2038        pass
2039
2040    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
2041        """
2042        B.endswith(suffix[, start[, end]]) -> bool
2043        
2044        Return True if B ends with the specified suffix, False otherwise.
2045        With optional start, test B beginning at that position.
2046        With optional end, stop comparing B at that position.
2047        suffix can also be a tuple of bytes to try.
2048        """
2049        return False
2050
2051    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
2052        """
2053        B.expandtabs(tabsize=8) -> copy of B
2054        
2055        Return a copy of B where all tab characters are expanded using spaces.
2056        If tabsize is not given, a tab size of 8 characters is assumed.
2057        """
2058        pass
2059
2060    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2061        """
2062        B.find(sub[, start[, end]]) -> int
2063        
2064        Return the lowest index in B where subsection sub is found,
2065        such that sub is contained within B[start,end].  Optional
2066        arguments start and end are interpreted as in slice notation.
2067        
2068        Return -1 on failure.
2069        """
2070        return 0
2071
2072    @classmethod # known case
2073    def fromhex(cls, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
2074        """
2075        Create a bytes object from a string of hexadecimal numbers.
2076        
2077        Spaces between two numbers are accepted.
2078        Example: bytes.fromhex('B9 01EF') -> b'\\xb9\\x01\\xef'.
2079        """
2080        pass
2081
2082    def hex(self): # real signature unknown; restored from __doc__
2083        """
2084        B.hex() -> string
2085        
2086        Create a string of hexadecimal numbers from a bytes object.
2087        Example: b'\xb9\x01\xef'.hex() -> 'b901ef'.
2088        """
2089        return ""
2090
2091    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2092        """
2093        B.index(sub[, start[, end]]) -> int
2094        
2095        Return the lowest index in B where subsection sub is found,
2096        such that sub is contained within B[start,end].  Optional
2097        arguments start and end are interpreted as in slice notation.
2098        
2099        Raises ValueError when the subsection is not found.
2100        """
2101        return 0
2102
2103    def isalnum(self): # real signature unknown; restored from __doc__
2104        """
2105        B.isalnum() -> bool
2106        
2107        Return True if all characters in B are alphanumeric
2108        and there is at least one character in B, False otherwise.
2109        """
2110        return False
2111
2112    def isalpha(self): # real signature unknown; restored from __doc__
2113        """
2114        B.isalpha() -> bool
2115        
2116        Return True if all characters in B are alphabetic
2117        and there is at least one character in B, False otherwise.
2118        """
2119        return False
2120
2121    def isdigit(self): # real signature unknown; restored from __doc__
2122        """
2123        B.isdigit() -> bool
2124        
2125        Return True if all characters in B are digits
2126        and there is at least one character in B, False otherwise.
2127        """
2128        return False
2129
2130    def islower(self): # real signature unknown; restored from __doc__
2131        """
2132        B.islower() -> bool
2133        
2134        Return True if all cased characters in B are lowercase and there is
2135        at least one cased character in B, False otherwise.
2136        """
2137        return False
2138
2139    def isspace(self): # real signature unknown; restored from __doc__
2140        """
2141        B.isspace() -> bool
2142        
2143        Return True if all characters in B are whitespace
2144        and there is at least one character in B, False otherwise.
2145        """
2146        return False
2147
2148    def istitle(self): # real signature unknown; restored from __doc__
2149        """
2150        B.istitle() -> bool
2151        
2152        Return True if B is a titlecased string and there is at least one
2153        character in B, i.e. uppercase characters may only follow uncased
2154        characters and lowercase characters only cased ones. Return False
2155        otherwise.
2156        """
2157        return False
2158
2159    def isupper(self): # real signature unknown; restored from __doc__
2160        """
2161        B.isupper() -> bool
2162        
2163        Return True if all cased characters in B are uppercase and there is
2164        at least one cased character in B, False otherwise.
2165        """
2166        return False
2167
2168    def join(self, *args, **kwargs): # real signature unknown; NOTE: unreliably restored from __doc__ 
2169        """
2170        Concatenate any number of bytes objects.
2171        
2172        The bytes whose method is called is inserted in between each pair.
2173        
2174        The result is returned as a new bytes object.
2175        
2176        Example: b'.'.join([b'ab', b'pq', b'rs']) -> b'ab.pq.rs'.
2177        """
2178        pass
2179
2180    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
2181        """
2182        B.ljust(width[, fillchar]) -> copy of B
2183        
2184        Return B left justified in a string of length width. Padding is
2185        done using the specified fill character (default is a space).
2186        """
2187        pass
2188
2189    def lower(self): # real signature unknown; restored from __doc__
2190        """
2191        B.lower() -> copy of B
2192        
2193        Return a copy of B with all ASCII characters converted to lowercase.
2194        """
2195        pass
2196
2197    def lstrip(self, *args, **kwargs): # real signature unknown
2198        """
2199        Strip leading bytes contained in the argument.
2200        
2201        If the argument is omitted or None, strip leading  ASCII whitespace.
2202        """
2203        pass
2204
2205    @staticmethod # known case
2206    def maketrans(*args, **kwargs): # real signature unknown
2207        """
2208        Return a translation table useable for the bytes or bytearray translate method.
2209        
2210        The returned table will be one where each byte in frm is mapped to the byte at
2211        the same position in to.
2212        
2213        The bytes objects frm and to must be of the same length.
2214        """
2215        pass
2216
2217    def partition(self, *args, **kwargs): # real signature unknown
2218        """
2219        Partition the bytes into three parts using the given separator.
2220        
2221        This will search for the separator sep in the bytes. If the separator is found,
2222        returns a 3-tuple containing the part before the separator, the separator
2223        itself, and the part after it.
2224        
2225        If the separator is not found, returns a 3-tuple containing the original bytes
2226        object and two empty bytes objects.
2227        """
2228        pass
2229
2230    def replace(self, *args, **kwargs): # real signature unknown
2231        """
2232        Return a copy with all occurrences of substring old replaced by new.
2233        
2234          count
2235            Maximum number of occurrences to replace.
2236            -1 (the default value) means replace all occurrences.
2237        
2238        If the optional argument count is given, only the first count occurrences are
2239        replaced.
2240        """
2241        pass
2242
2243    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2244        """
2245        B.rfind(sub[, start[, end]]) -> int
2246        
2247        Return the highest index in B where subsection sub is found,
2248        such that sub is contained within B[start,end].  Optional
2249        arguments start and end are interpreted as in slice notation.
2250        
2251        Return -1 on failure.
2252        """
2253        return 0
2254
2255    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
2256        """
2257        B.rindex(sub[, start[, end]]) -> int
2258        
2259        Return the highest index in B where subsection sub is found,
2260        such that sub is contained within B[start,end].  Optional
2261        arguments start and end are interpreted as in slice notation.
2262        
2263        Raise ValueError when the subsection is not found.
2264        """
2265        return 0
2266
2267    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
2268        """
2269        B.rjust(width[, fillchar]) -> copy of B
2270        
2271        Return B right justified in a string of length width. Padding is
2272        done using the specified fill character (default is a space)
2273        """
2274        pass
2275
2276    def rpartition(self, *args, **kwargs): # real signature unknown
2277        """
2278        Partition the bytes into three parts using the given separator.
2279        
2280        This will search for the separator sep in the bytes, starting at the end. If
2281        the separator is found, returns a 3-tuple containing the part before the
2282        separator, the separator itself, and the part after it.
2283        
2284        If the separator is not found, returns a 3-tuple containing two empty bytes
2285        objects and the original bytes object.
2286        """
2287        pass
2288
2289    def rsplit(self, *args, **kwargs): # real signature unknown
2290        """
2291        Return a list of the sections in the bytes, using sep as the delimiter.
2292        
2293          sep
2294            The delimiter according which to split the bytes.
2295            None (the default value) means split on ASCII whitespace characters
2296            (space, tab, return, newline, formfeed, vertical tab).
2297          maxsplit
2298            Maximum number of splits to do.
2299            -1 (the default value) means no limit.
2300        
2301        Splitting is done starting at the end of the bytes and working to the front.
2302        """
2303        pass
2304
2305    def rstrip(self, *args, **kwargs): # real signature unknown
2306        """
2307        Strip trailing bytes contained in the argument.
2308        
2309        If the argument is omitted or None, strip trailing ASCII whitespace.
2310        """
2311        pass
2312
2313    def split(self, *args, **kwargs): # real signature unknown
2314        """
2315        Return a list of the sections in the bytes, using sep as the delimiter.
2316        
2317          sep
2318            The delimiter according which to split the bytes.
2319            None (the default value) means split on ASCII whitespace characters
2320            (space, tab, return, newline, formfeed, vertical tab).
2321          maxsplit
2322            Maximum number of splits to do.
2323            -1 (the default value) means no limit.
2324        """
2325        pass
2326
2327    def splitlines(self, *args, **kwargs): # real signature unknown
2328        """
2329        Return a list of the lines in the bytes, breaking at line boundaries.
2330        
2331        Line breaks are not included in the resulting list unless keepends is given and
2332        true.
2333        """
2334        pass
2335
2336    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
2337        """
2338        B.startswith(prefix[, start[, end]]) -> bool
2339        
2340        Return True if B starts with the specified prefix, False otherwise.
2341        With optional start, test B beginning at that position.
2342        With optional end, stop comparing B at that position.
2343        prefix can also be a tuple of bytes to try.
2344        """
2345        return False
2346
2347    def strip(self, *args, **kwargs): # real signature unknown
2348        """
2349        Strip leading and trailing bytes contained in the argument.
2350        
2351        If the argument is omitted or None, strip leading and trailing ASCII whitespace.
2352        """
2353        pass
2354
2355    def swapcase(self): # real signature unknown; restored from __doc__
2356        """
2357        B.swapcase() -> copy of B
2358        
2359        Return a copy of B with uppercase ASCII characters converted
2360        to lowercase ASCII and vice versa.
2361        """
2362        pass
2363
2364    def title(self): # real signature unknown; restored from __doc__
2365        """
2366        B.title() -> copy of B
2367        
2368        Return a titlecased version of B, i.e. ASCII words start with uppercase
2369        characters, all remaining cased characters have lowercase.
2370        """
2371        pass
2372
2373    def translate(self, *args, **kwargs): # real signature unknown
2374        """
2375        Return a copy with each character mapped by the given translation table.
2376        
2377          table
2378            Translation table, which must be a bytes object of length 256.
2379        
2380        All characters occurring in the optional argument delete are removed.
2381        The remaining characters are mapped through the given translation table.
2382        """
2383        pass
2384
2385    def upper(self): # real signature unknown; restored from __doc__
2386        """
2387        B.upper() -> copy of B
2388        
2389        Return a copy of B with all ASCII characters converted to uppercase.
2390        """
2391        pass
2392
2393    def zfill(self, width): # real signature unknown; restored from __doc__
2394        """
2395        B.zfill(width) -> copy of B
2396        
2397        Pad a numeric string B with zeros on the left, to fill a field
2398        of the specified width.  B is never truncated.
2399        """
2400        pass
2401
2402    def __add__(self, *args, **kwargs): # real signature unknown
2403        """ Return self+value. """
2404        pass
2405
2406    def __contains__(self, *args, **kwargs): # real signature unknown
2407        """ Return key in self. """
2408        pass
2409
2410    def __eq__(self, *args, **kwargs): # real signature unknown
2411        """ Return self==value. """
2412        pass
2413
2414    def __getattribute__(self, *args, **kwargs): # real signature unknown
2415        """ Return getattr(self, name). """
2416        pass
2417
2418    def __getitem__(self, *args, **kwargs): # real signature unknown
2419        """ Return self[key]. """
2420        pass
2421
2422    def __getnewargs__(self, *args, **kwargs): # real signature unknown
2423        pass
2424
2425    def __ge__(self, *args, **kwargs): # real signature unknown
2426        """ Return self>=value. """
2427        pass
2428
2429    def __gt__(self, *args, **kwargs): # real signature unknown
2430        """ Return self>value. """
2431        pass
2432
2433    def __hash__(self, *args, **kwargs): # real signature unknown
2434        """ Return hash(self). """
2435        pass
2436
2437    def __init__(self, value=b'', encoding=None, errors='strict'): # known special case of bytes.__init__
2438        """
2439        bytes(iterable_of_ints) -> bytes
2440        bytes(string, encoding[, errors]) -> bytes
2441        bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
2442        bytes(int) -> bytes object of size given by the parameter initialized with null bytes
2443        bytes() -> empty bytes object
2444        
2445        Construct an immutable array of bytes from:
2446          - an iterable yielding integers in range(256)
2447          - a text string encoded using the specified encoding
2448          - any object implementing the buffer API.
2449          - an integer
2450        # (copied from class doc)
2451        """
2452        pass
2453
2454    def __iter__(self, *args, **kwargs): # real signature unknown
2455        """ Implement iter(self). """
2456        pass
2457
2458    def __len__(self, *args, **kwargs): # real signature unknown
2459        """ Return len(self). """
2460        pass
2461
2462    def __le__(self, *args, **kwargs): # real signature unknown
2463        """ Return self<=value. """
2464        pass
2465
2466    def __lt__(self, *args, **kwargs): # real signature unknown
2467        """ Return self<value. """
2468        pass
2469
2470    def __mod__(self, *args, **kwargs): # real signature unknown
2471        """ Return self%value. """
2472        pass
2473
2474    def __mul__(self, *args, **kwargs): # real signature unknown
2475        """ Return self*value.n """
2476        pass
2477
2478    @staticmethod # known case of __new__
2479    def __new__(*args, **kwargs): # real signature unknown
2480        """ Create and return a new object.  See help(type) for accurate signature. """
2481        pass
2482
2483    def __ne__(self, *args, **kwargs): # real signature unknown
2484        """ Return self!=value. """
2485        pass
2486
2487    def __repr__(self, *args, **kwargs): # real signature unknown
2488        """ Return repr(self). """
2489        pass
2490
2491    def __rmod__(self, *args, **kwargs): # real signature unknown
2492        """ Return value%self. """
2493        pass
2494
2495    def __rmul__(self, *args, **kwargs): # real signature unknown
2496        """ Return self*value. """
2497        pass
2498
2499    def __str__(self, *args, **kwargs): # real signature unknown
2500        """ Return str(self). """
2501        pass
2502
2503
2504class Warning(Exception):
2505    """ Base class for warning categories. """
2506    def __init__(self, *args, **kwargs): # real signature unknown
2507        pass
2508
2509    @staticmethod # known case of __new__
2510    def __new__(*args, **kwargs): # real signature unknown
2511        """ Create and return a new object.  See help(type) for accurate signature. """
2512        pass
2513
2514
2515class BytesWarning(Warning):
2516    """
2517    Base class for warnings about bytes and buffer related problems, mostly
2518    related to conversion from str or comparing to str.
2519    """
2520    def __init__(self, *args, **kwargs): # real signature unknown
2521        pass
2522
2523    @staticmethod # known case of __new__
2524    def __new__(*args, **kwargs): # real signature unknown
2525        """ Create and return a new object.  See help(type) for accurate signature. """
2526        pass
2527
2528
2529class ChildProcessError(OSError):
2530    """ Child process error. """
2531    def __init__(self, *args, **kwargs): # real signature unknown
2532        pass
2533
2534
2535class classmethod(object):
2536    """
2537    classmethod(function) -> method
2538    
2539    Convert a function to be a class method.
2540    
2541    A class method receives the class as implicit first argument,
2542    just like an instance method receives the instance.
2543    To declare a class method, use this idiom:
2544    
2545      class C:
2546          @classmethod
2547          def f(cls, arg1, arg2, ...):
2548              ...
2549    
2550    It can be called either on the class (e.g. C.f()) or on an instance
2551    (e.g. C().f()).  The instance is ignored except for its class.
2552    If a class method is called for a derived class, the derived class
2553    object is passed as the implied first argument.
2554    
2555    Class methods are different than C++ or Java static methods.
2556    If you want those, see the staticmethod builtin.
2557    """
2558    def __get__(self, *args, **kwargs): # real signature unknown
2559        """ Return an attribute of instance, which is of type owner. """
2560        pass
2561
2562    def __init__(self, function): # real signature unknown; restored from __doc__
2563        pass
2564
2565    @staticmethod # known case of __new__
2566    def __new__(*args, **kwargs): # real signature unknown
2567        """ Create and return a new object.  See help(type) for accurate signature. """
2568        pass
2569
2570    __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
2571
2572    __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
2573
2574
2575    __dict__ = None # (!) real value is ''
2576
2577
2578class complex(object):
2579    """
2580    complex(real[, imag]) -> complex number
2581    
2582    Create a complex number from a real part and an optional imaginary part.
2583    This is equivalent to (real + imag*1j) where imag defaults to 0.
2584    """
2585    def conjugate(self): # real signature unknown; restored from __doc__
2586        """
2587        complex.conjugate() -> complex
2588        
2589        Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
2590        """
2591        return complex
2592
2593    def __abs__(self, *args, **kwargs): # real signature unknown
2594        """ abs(self) """
2595        pass
2596
2597    def __add__(self, *args, **kwargs): # real signature unknown
2598        """ Return self+value. """
2599        pass
2600
2601    def __bool__(self, *args, **kwargs): # real signature unknown
2602        """ self != 0 """
2603        pass
2604
2605    def __divmod__(self, *args, **kwargs): # real signature unknown
2606        """ Return divmod(self, value). """
2607        pass
2608
2609    def __eq__(self, *args, **kwargs): # real signature unknown
2610        """ Return self==value. """
2611        pass
2612
2613    def __float__(self, *args, **kwargs): # real signature unknown
2614        """ float(self) """
2615        pass
2616
2617    def __floordiv__(self, *args, **kwargs): # real signature unknown
2618        """ Return self//value. """
2619        pass
2620
2621    def __format__(self): # real signature unknown; restored from __doc__
2622        """
2623        complex.__format__() -> str
2624        
2625        Convert to a string according to format_spec.
2626        """
2627        return ""
2628
2629    def __getattribute__(self, *args, **kwargs): # real signature unknown
2630        """ Return getattr(self, name). """
2631        pass
2632
2633    def __getnewargs__(self, *args, **kwargs): # real signature unknown
2634        pass
2635
2636    def __ge__(self, *args, **kwargs): # real signature unknown
2637        """ Return self>=value. """
2638        pass
2639
2640    def __gt__(self, *args, **kwargs): # real signature unknown
2641        """ Return self>value. """
2642        pass
2643
2644    def __hash__(self, *args, **kwargs): # real signature unknown
2645        """ Return hash(self). """
2646        pass
2647
2648    def __init__(self, real, imag=None): # real signature unknown; restored from __doc__
2649        pass
2650
2651    def __int__(self, *args, **kwargs): # real signature unknown
2652        """ int(self) """
2653        pass
2654
2655    def __le__(self, *args, **kwargs): # real signature unknown
2656        """ Return self<=value. """
2657        pass
2658
2659    def __lt__(self, *args, **kwargs): # real signature unknown
2660        """ Return self<value. """
2661        pass
2662
2663    def __mod__(self, *args, **kwargs): # real signature unknown
2664        """ Return self%value. """
2665        pass
2666
2667    def __mul__(self, *args, **kwargs): # real signature unknown
2668        """ Return self*value. """
2669        pass
2670
2671    def __neg__(self, *args, **kwargs): # real signature unknown
2672        """ -self """
2673        pass
2674
2675    @staticmethod # known case of __new__
2676    def __new__(*args, **kwargs): # real signature unknown
2677        """ Create and return a new object.  See help(type) for accurate signature. """
2678        pass
2679
2680    def __ne__(self, *args, **kwargs): # real signature unknown
2681        """ Return self!=value. """
2682        pass
2683
2684    def __pos__(self, *args, **kwargs): # real signature unknown
2685        """ +self """
2686        pass
2687
2688    def __pow__(self, *args, **kwargs): # real signature unknown
2689        """ Return pow(self, value, mod). """
2690        pass
2691
2692    def __radd__(self, *args, **kwargs): # real signature unknown
2693        """ Return value+self. """
2694        pass
2695
2696    def __rdivmod__(self, *args, **kwargs): # real signature unknown
2697        """ Return divmod(value, self). """
2698        pass
2699
2700    def __repr__(self, *args, **kwargs): # real signature unknown
2701        """ Return repr(self). """
2702        pass
2703
2704    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2705        """ Return value//self. """
2706        pass
2707
2708    def __rmod__(self, *args, **kwargs): # real signature unknown
2709        """ Return value%self. """
2710        pass
2711
2712    def __rmul__(self, *args, **kwargs): # real signature unknown
2713        """ Return value*self. """
2714        pass
2715
2716    def __rpow__(self, *args, **kwargs): # real signature unknown
2717        """ Return pow(value, self, mod). """
2718        pass
2719
2720    def __rsub__(self, *args, **kwargs): # real signature unknown
2721        """ Return value-self. """
2722        pass
2723
2724    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2725        """ Return value/self. """
2726        pass
2727
2728    def __str__(self, *args, **kwargs): # real signature unknown
2729        """ Return str(self). """
2730        pass
2731
2732    def __sub__(self, *args, **kwargs): # real signature unknown
2733        """ Return self-value. """
2734        pass
2735
2736    def __truediv__(self, *args, **kwargs): # real signature unknown
2737        """ Return self/value. """
2738        pass
2739
2740    imag = property(lambda self: 0.0)
2741    """the imaginary part of a complex number
2742
2743    :type: float
2744    """
2745
2746    real = property(lambda self: 0.0)
2747    """the real part of a complex number
2748
2749    :type: float
2750    """
2751
2752
2753
2754class ConnectionAbortedError(ConnectionError):
2755    """ Connection aborted. """
2756    def __init__(self, *args, **kwargs): # real signature unknown
2757        pass
2758
2759
2760class ConnectionRefusedError(ConnectionError):
2761    """ Connection refused. """
2762    def __init__(self, *args, **kwargs): # real signature unknown
2763        pass
2764
2765
2766class ConnectionResetError(ConnectionError):
2767    """ Connection reset. """
2768    def __init__(self, *args, **kwargs): # real signature unknown
2769        pass
2770
2771
2772class DeprecationWarning(Warning):
2773    """ Base class for warnings about deprecated features. """
2774    def __init__(self, *args, **kwargs): # real signature unknown
2775        pass
2776
2777    @staticmethod # known case of __new__
2778    def __new__(*args, **kwargs): # real signature unknown
2779        """ Create and return a new object.  See help(type) for accurate signature. """
2780        pass
2781
2782
2783class dict(object):
2784    """
2785    dict() -> new empty dictionary
2786    dict(mapping) -> new dictionary initialized from a mapping object's
2787        (key, value) pairs
2788    dict(iterable) -> new dictionary initialized as if via:
2789        d = {}
2790        for k, v in iterable:
2791            d[k] = v
2792    dict(**kwargs) -> new dictionary initialized with the name=value pairs
2793        in the keyword argument list.  For example:  dict(one=1, two=2)
2794    """
2795    def clear(self): # real signature unknown; restored from __doc__
2796        """ D.clear() -> None.  Remove all items from D. """
2797        pass
2798
2799    def copy(self): # real signature unknown; restored from __doc__
2800        """ D.copy() -> a shallow copy of D """
2801        pass
2802
2803    @staticmethod # known case
2804    def fromkeys(*args, **kwargs): # real signature unknown
2805        """ Returns a new dict with keys from iterable and values equal to value. """
2806        pass
2807
2808    def get(self, k, d=None): # real signature unknown; restored from __doc__
2809        """ D.get(k[,d]) -> D[k] if k in D, else d.  d defaults to None. """
2810        pass
2811
2812    def items(self): # real signature unknown; restored from __doc__
2813        """ D.items() -> a set-like object providing a view on D's items """
2814        pass
2815
2816    def keys(self): # real signature unknown; restored from __doc__
2817        """ D.keys() -> a set-like object providing a view on D's keys """
2818        pass
2819
2820    def pop(self, k, d=None): # real signature unknown; restored from __doc__
2821        """
2822        D.pop(k[,d]) -> v, remove specified key and return the corresponding value.
2823        If key is not found, d is returned if given, otherwise KeyError is raised
2824        """
2825        pass
2826
2827    def popitem(self): # real signature unknown; restored from __doc__
2828        """
2829        D.popitem() -> (k, v), remove and return some (key, value) pair as a
2830        2-tuple; but raise KeyError if D is empty.
2831        """
2832        pass
2833
2834    def setdefault(self, k, d=None): # real signature unknown; restored from __doc__
2835        """ D.setdefault(k[,d]) -> D.get(k,d), also set D[k]=d if k not in D """
2836        pass
2837
2838    def update(self, E=None, **F): # known special case of dict.update
2839        """
2840        D.update([E, ]**F) -> None.  Update D from dict/iterable E and F.
2841        If E is present and has a .keys() method, then does:  for k in E: D[k] = E[k]
2842        If E is present and lacks a .keys() method, then does:  for k, v in E: D[k] = v
2843        In either case, this is followed by: for k in F:  D[k] = F[k]
2844        """
2845        pass
2846
2847    def values(self): # real signature unknown; restored from __doc__
2848        """ D.values() -> an object providing a view on D's values """
2849        pass
2850
2851    def __contains__(self, *args, **kwargs): # real signature unknown
2852        """ True if D has a key k, else False. """
2853        pass
2854
2855    def __delitem__(self, *args, **kwargs): # real signature unknown
2856        """ Delete self[key]. """
2857        pass
2858
2859    def __eq__(self, *args, **kwargs): # real signature unknown
2860        """ Return self==value. """
2861        pass
2862
2863    def __getattribute__(self, *args, **kwargs): # real signature unknown
2864        """ Return getattr(self, name). """
2865        pass
2866
2867    def __getitem__(self, y): # real signature unknown; restored from __doc__
2868        """ x.__getitem__(y) <==> x[y] """
2869        pass
2870
2871    def __ge__(self, *args, **kwargs): # real signature unknown
2872        """ Return self>=value. """
2873        pass
2874
2875    def __gt__(self, *args, **kwargs): # real signature unknown
2876        """ Return self>value. """
2877        pass
2878
2879    def __init__(self, seq=None, **kwargs): # known special case of dict.__init__
2880        """
2881        dict() -> new empty dictionary
2882        dict(mapping) -> new dictionary initialized from a mapping object's
2883            (key, value) pairs
2884        dict(iterable) -> new dictionary initialized as if via:
2885            d = {}
2886            for k, v in iterable:
2887                d[k] = v
2888        dict(**kwargs) -> new dictionary initialized with the name=value pairs
2889            in the keyword argument list.  For example:  dict(one=1, two=2)
2890        # (copied from class doc)
2891        """
2892        pass
2893
2894    def __iter__(self, *args, **kwargs): # real signature unknown
2895        """ Implement iter(self). """
2896        pass
2897
2898    def __len__(self, *args, **kwargs): # real signature unknown
2899        """ Return len(self). """
2900        pass
2901
2902    def __le__(self, *args, **kwargs): # real signature unknown
2903        """ Return self<=value. """
2904        pass
2905
2906    def __lt__(self, *args, **kwargs): # real signature unknown
2907        """ Return self<value. """
2908        pass
2909
2910    @staticmethod # known case of __new__
2911    def __new__(*args, **kwargs): # real signature unknown
2912        """ Create and return a new object.  See help(type) for accurate signature. """
2913        pass
2914
2915    def __ne__(self, *args, **kwargs): # real signature unknown
2916        """ Return self!=value. """
2917        pass
2918
2919    def __repr__(self, *args, **kwargs): # real signature unknown
2920        """ Return repr(self). """
2921        pass
2922
2923    def __setitem__(self, *args, **kwargs): # real signature unknown
2924        """ Set self[key] to value. """
2925        pass
2926
2927    def __sizeof__(self): # real signature unknown; restored from __doc__
2928        """ D.__sizeof__() -> size of D in memory, in bytes """
2929        pass
2930
2931    __hash__ = None
2932
2933
2934class enumerate(object):
2935    """
2936    enumerate(iterable[, start]) -> iterator for index, value of iterable
2937    
2938    Return an enumerate object.  iterable must be another object that supports
2939    iteration.  The enumerate object yields pairs containing a count (from
2940    start, which defaults to zero) and a value yielded by the iterable argument.
2941    enumerate is useful for obtaining an indexed list:
2942        (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
2943    """
2944    def __getattribute__(self, *args, **kwargs): # real signature unknown
2945        """ Return getattr(self, name). """
2946        pass
2947
2948    def __init__(self, iterable, start=0): # known special case of enumerate.__init__
2949        """ Initialize self.  See help(type(self)) for accurate signature. """
2950        pass
2951
2952    def __iter__(self, *args, **kwargs): # real signature unknown
2953        """ Implement iter(self). """
2954        pass
2955
2956    @staticmethod # known case of __new__
2957    def __new__(*args, **kwargs): # real signature unknown
2958        """ Create and return a new object.  See help(type) for accurate signature. """
2959        pass
2960
2961    def __next__(self, *args, **kwargs): # real signature unknown
2962        """ Implement next(self). """
2963        pass
2964
2965    def __reduce__(self, *args, **kwargs): # real signature unknown
2966        """ Return state information for pickling. """
2967        pass
2968
2969
2970class EOFError(Exception):
2971    """ Read beyond end of file. """
2972    def __init__(self, *args, **kwargs): # real signature unknown
2973        pass
2974
2975    @staticmethod # known case of __new__
2976    def __new__(*args, **kwargs): # real signature unknown
2977        """ Create and return a new object.  See help(type) for accurate signature. """
2978        pass
2979
2980
2981class FileExistsError(OSError):
2982    """ File already exists. """
2983    def __init__(self, *args, **kwargs): # real signature unknown
2984        pass
2985
2986
2987class FileNotFoundError(OSError):
2988    """ File not found. """
2989    def __init__(self, *args, **kwargs): # real signature unknown
2990        pass
2991
2992
2993class filter(object):
2994    """
2995    filter(function or None, iterable) --> filter object
2996    
2997    Return an iterator yielding those items of iterable for which function(item)
2998    is true. If function is None, return the items that are true.
2999    """
3000    def __getattribute__(self, *args, **kwargs): # real signature unknown
3001        """ Return getattr(self, name). """
3002        pass
3003
3004    def __init__(self, function_or_None, iterable): # real signature unknown; restored from __doc__
3005        pass
3006
3007    def __iter__(self, *args, **kwargs): # real signature unknown
3008        """ Implement iter(self). """
3009        pass
3010
3011    @staticmethod # known case of __new__
3012    def __new__(*args, **kwargs): # real signature unknown
3013        """ Create and return a new object.  See help(type) for accurate signature. """
3014        pass
3015
3016    def __next__(self, *args, **kwargs): # real signature unknown
3017        """ Implement next(self). """
3018        pass
3019
3020    def __reduce__(self, *args, **kwargs): # real signature unknown
3021        """ Return state information for pickling. """
3022        pass
3023
3024
3025class float(object):
3026    """
3027    float(x) -> floating point number
3028    
3029    Convert a string or number to a floating point number, if possible.
3030    """
3031    def as_integer_ratio(self): # real signature unknown; restored from __doc__
3032        """
3033        float.as_integer_ratio() -> (int, int)
3034        
3035        Return a pair of integers, whose ratio is exactly equal to the original
3036        float and with a positive denominator.
3037        Raise OverflowError on infinities and a ValueError on NaNs.
3038        
3039        >>> (10.0).as_integer_ratio()
3040        (10, 1)
3041        >>> (0.0).as_integer_ratio()
3042        (0, 1)
3043        >>> (-.25).as_integer_ratio()
3044        (-1, 4)
3045        """
3046        pass
3047
3048    def conjugate(self, *args, **kwargs): # real signature unknown
3049        """ Return self, the complex conjugate of any float. """
3050        pass
3051
3052    @staticmethod # known case
3053    def fromhex(string): # real signature unknown; restored from __doc__
3054        """
3055        float.fromhex(string) -> float
3056        
3057        Create a floating-point number from a hexadecimal string.
3058        >>> float.fromhex('0x1.ffffp10')
3059        2047.984375
3060        >>> float.fromhex('-0x1p-1074')
3061        -5e-324
3062        """
3063        return 0.0
3064
3065    def hex(self): # real signature unknown; restored from __doc__
3066        """
3067        float.hex() -> string
3068        
3069        Return a hexadecimal representation of a floating-point number.
3070        >>> (-0.1).hex()
3071        '-0x1.999999999999ap-4'
3072        >>> 3.14159.hex()
3073        '0x1.921f9f01b866ep+1'
3074        """
3075        return ""
3076
3077    def is_integer(self, *args, **kwargs): # real signature unknown
3078        """ Return True if the float is an integer. """
3079        pass
3080
3081    def __abs__(self, *args, **kwargs): # real signature unknown
3082        """ abs(self) """
3083        pass
3084
3085    def __add__(self, *args, **kwargs): # real signature unknown
3086        """ Return self+value. """
3087        pass
3088
3089    def __bool__(self, *args, **kwargs): # real signature unknown
3090        """ self != 0 """
3091        pass
3092
3093    def __divmod__(self, *args, **kwargs): # real signature unknown
3094        """ Return divmod(self, value). """
3095        pass
3096
3097    def __eq__(self, *args, **kwargs): # real signature unknown
3098        """ Return self==value. """
3099        pass
3100
3101    def __float__(self, *args, **kwargs): # real signature unknown
3102        """ float(self) """
3103        pass
3104
3105    def __floordiv__(self, *args, **kwargs): # real signature unknown
3106        """ Return self//value. """
3107        pass
3108
3109    def __format__(self, format_spec): # real signature unknown; restored from __doc__
3110        """
3111        float.__format__(format_spec) -> string
3112        
3113        Formats the float according to format_spec.
3114        """
3115        return ""
3116
3117    def __getattribute__(self, *args, **kwargs): # real signature unknown
3118        """ Return getattr(self, name). """
3119        pass
3120
3121    def __getformat__(self, typestr): # real signature unknown; restored from __doc__
3122        """
3123        float.__getformat__(typestr) -> string
3124        
3125        You probably don't want to use this function.  It exists mainly to be
3126        used in Python's test suite.
3127        
3128        typestr must be 'double' or 'float'.  This function returns whichever of
3129        'unknown', 'IEEE, big-endian' or 'IEEE, little-endian' best describes the
3130        format of floating point numbers used by the C type named by typestr.
3131        """
3132        return ""
3133
3134    def __getnewargs__(self, *args, **kwargs): # real signature unknown
3135        pass
3136
3137    def __ge__(self, *args, **kwargs): # real signature unknown
3138        """ Return self>=value. """
3139        pass
3140
3141    def __gt__(self, *args, **kwargs): # real signature unknown
3142        """ Return self>value. """
3143        pass
3144
3145    def __hash__(self, *args, **kwargs): # real signature unknown
3146        """ Return hash(self). """
3147        pass
3148
3149    def __init__(self, x): # real signature unknown; restored from __doc__
3150        pass
3151
3152    def __int__(self, *args, **kwargs): # real signature unknown
3153        """ int(self) """
3154        pass
3155
3156    def __le__(self, *args, **kwargs): # real signature unknown
3157        """ Return self<=value. """
3158        pass
3159
3160    def __lt__(self, *args, **kwargs): # real signature unknown
3161        """ Return self<value. """
3162        pass
3163
3164    def __mod__(self, *args, **kwargs): # real signature unknown
3165        """ Return self%value. """
3166        pass
3167
3168    def __mul__(self, *args, **kwargs): # real signature unknown
3169        """ Return self*value. """
3170        pass
3171
3172    def __neg__(self, *args, **kwargs): # real signature unknown
3173        """ -self """
3174        pass
3175
3176    @staticmethod # known case of __new__
3177    def __new__(*args, **kwargs): # real signature unknown
3178        """ Create and return a new object.  See help(type) for accurate signature. """
3179        pass
3180
3181    def __ne__(self, *args, **kwargs): # real signature unknown
3182        """ Return self!=value. """
3183        pass
3184
3185    def __pos__(self, *args, **kwargs): # real signature unknown
3186        """ +self """
3187        pass
3188
3189    def __pow__(self, *args, **kwargs): # real signature unknown
3190        """ Return pow(self, value, mod). """
3191        pass
3192
3193    def __radd__(self, *args, **kwargs): # real signature unknown
3194        """ Return value+self. """
3195        pass
3196
3197    def __rdivmod__(self, *args, **kwargs): # real signature unknown
3198        """ Return divmod(value, self). """
3199        pass
3200
3201    def __repr__(self, *args, **kwargs): # real signature unknown
3202        """ Return repr(self). """
3203        pass
3204
3205    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
3206        """ Return value//self. """
3207        pass
3208
3209    def __rmod__(self, *args, **kwargs): # real signature unknown
3210        """ Return value%self. """
3211        pass
3212
3213    def __rmul__(self, *args, **kwargs): # real signature unknown
3214        """ Return value*self. """
3215        pass
3216
3217    def __round__(self, *args, **kwargs): # real signature unknown
3218        """
3219        Return the Integral closest to x, rounding half toward even.
3220        When an argument is passed, work like built-in round(x, ndigits).
3221        """
3222        pass
3223
3224    def __rpow__(self, *args, **kwargs): # real signature unknown
3225        """ Return pow(value, self, mod). """
3226        pass
3227
3228    def __rsub__(self, *args, **kwargs): # real signature unknown
3229        """ Return value-self. """
3230        pass
3231
3232    def __rtruediv__(self, *args, **kwargs): # real signature unknown
3233        """ Return value/self. """
3234        pass
3235
3236    def __setformat__(self, typestr, fmt): # real signature unknown; restored from __doc__
3237        """
3238        float.__setformat__(typestr, fmt) -> None
3239        
3240        You probably don't want to use this function.  It exists mainly to be
3241        used in Python's test suite.
3242        
3243        typestr must be 'double' or 'float'.  fmt must be one of 'unknown',
3244        'IEEE, big-endian' or 'IEEE, little-endian', and in addition can only be
3245        one of the latter two if it appears to match the underlying C reality.
3246        
3247        Override the automatic determination of C-level floating point type.
3248        This affects how floats are converted to and from binary strings.
3249        """
3250        pass
3251
3252    def __str__(self, *args, **kwargs): # real signature unknown
3253        """ Return str(self). """
3254        pass
3255
3256    def __sub__(self, *args, **kwargs): # real signature unknown
3257        """ Return self-value. """
3258        pass
3259
3260    def __truediv__(self, *args, **kwargs): # real signature unknown
3261        """ Return self/value. """
3262        pass
3263
3264    def __trunc__(self, *args, **kwargs): # real signature unknown
3265        """ Return the Integral closest to x between 0 and x. """
3266        pass
3267
3268    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3269    """the imaginary part of a complex number"""
3270
3271    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3272    """the real part of a complex number"""
3273
3274
3275
3276class FloatingPointError(ArithmeticError):
3277    """ Floating point operation failed. """
3278    def __init__(self, *args, **kwargs): # real signature unknown
3279        pass
3280
3281    @staticmethod # known case of __new__
3282    def __new__(*args, **kwargs): # real signature unknown
3283        """ Create and return a new object.  See help(type) for accurate signature. """
3284        pass
3285
3286
3287class frozenset(object):
3288    """
3289    frozenset() -> empty frozenset object
3290    frozenset(iterable) -> frozenset object
3291    
3292    Build an immutable unordered collection of unique elements.
3293    """
3294    def copy(self, *args, **kwargs): # real signature unknown
3295        """ Return a shallow copy of a set. """
3296        pass
3297
3298    def difference(self, *args, **kwargs): # real signature unknown
3299        """
3300        Return the difference of two or more sets as a new set.
3301        
3302        (i.e. all elements that are in this set but not the others.)
3303        """
3304        pass
3305
3306    def intersection(self, *args, **kwargs): # real signature unknown
3307        """
3308        Return the intersection of two sets as a new set.
3309        
3310        (i.e. all elements that are in both sets.)
3311        """
3312        pass
3313
3314    def isdisjoint(self, *args, **kwargs): # real signature unknown
3315        """ Return True if two sets have a null intersection. """
3316        pass
3317
3318    def issubset(self, *args, **kwargs): # real signature unknown
3319        """ Report whether another set contains this set. """
3320        pass
3321
3322    def issuperset(self, *args, **kwargs): # real signature unknown
3323        """ Report whether this set contains another set. """
3324        pass
3325
3326    def symmetric_difference(self, *args, **kwargs): # real signature unknown
3327        """
3328        Return the symmetric difference of two sets as a new set.
3329        
3330        (i.e. all elements that are in exactly one of the sets.)
3331        """
3332        pass
3333
3334    def union(self, *args, **kwargs): # real signature unknown
3335        """
3336        Return the union of sets as a new set.
3337        
3338        (i.e. all elements that are in either set.)
3339        """
3340        pass
3341
3342    def __and__(self, *args, **kwargs): # real signature unknown
3343        """ Return self&value. """
3344        pass
3345
3346    def __contains__(self, y): # real signature unknown; restored from __doc__
3347        """ x.__contains__(y) <==> y in x. """
3348        pass
3349
3350    def __eq__(self, *args, **kwargs): # real signature unknown
3351        """ Return self==value. """
3352        pass
3353
3354    def __getattribute__(self, *args, **kwargs): # real signature unknown
3355        """ Return getattr(self, name). """
3356        pass
3357
3358    def __ge__(self, *args, **kwargs): # real signature unknown
3359        """ Return self>=value. """
3360        pass
3361
3362    def __gt__(self, *args, **kwargs): # real signature unknown
3363        """ Return self>value. """
3364        pass
3365
3366    def __hash__(self, *args, **kwargs): # real signature unknown
3367        """ Return hash(self). """
3368        pass
3369
3370    def __init__(self, seq=()): # known special case of frozenset.__init__
3371        """ Initialize self.  See help(type(self)) for accurate signature. """
3372        pass
3373
3374    def __iter__(self, *args, **kwargs): # real signature unknown
3375        """ Implement iter(self). """
3376        pass
3377
3378    def __len__(self, *args, **kwargs): # real signature unknown
3379        """ Return len(self). """
3380        pass
3381
3382    def __le__(self, *args, **kwargs): # real signature unknown
3383        """ Return self<=value. """
3384        pass
3385
3386    def __lt__(self, *args, **kwargs): # real signature unknown
3387        """ Return self<value. """
3388        pass
3389
3390    @staticmethod # known case of __new__
3391    def __new__(*args, **kwargs): # real signature unknown
3392        """ Create and return a new object.  See help(type) for accurate signature. """
3393        pass
3394
3395    def __ne__(self, *args, **kwargs): # real signature unknown
3396        """ Return self!=value. """
3397        pass
3398
3399    def __or__(self, *args, **kwargs): # real signature unknown
3400        """ Return self|value. """
3401        pass
3402
3403    def __rand__(self, *args, **kwargs): # real signature unknown
3404        """ Return value&self. """
3405        pass
3406
3407    def __reduce__(self, *args, **kwargs): # real signature unknown
3408        """ Return state information for pickling. """
3409        pass
3410
3411    def __repr__(self, *args, **kwargs): # real signature unknown
3412        """ Return repr(self). """
3413        pass
3414
3415    def __ror__(self, *args, **kwargs): # real signature unknown
3416        """ Return value|self. """
3417        pass
3418
3419    def __rsub__(self, *args, **kwargs): # real signature unknown
3420        """ Return value-self. """
3421        pass
3422
3423    def __rxor__(self, *args, **kwargs): # real signature unknown
3424        """ Return value^self. """
3425        pass
3426
3427    def __sizeof__(self): # real signature unknown; restored from __doc__
3428        """ S.__sizeof__() -> size of S in memory, in bytes """
3429        pass
3430
3431    def __sub__(self, *args, **kwargs): # real signature unknown
3432        """ Return self-value. """
3433        pass
3434
3435    def __xor__(self, *args, **kwargs): # real signature unknown
3436        """ Return self^value. """
3437        pass
3438
3439
3440class FutureWarning(Warning):
3441    """
3442    Base class for warnings about constructs that will change semantically
3443    in the future.
3444    """
3445    def __init__(self, *args, **kwargs): # real signature unknown
3446        pass
3447
3448    @staticmethod # known case of __new__
3449    def __new__(*args, **kwargs): # real signature unknown
3450        """ Create and return a new object.  See help(type) for accurate signature. """
3451        pass
3452
3453
3454class GeneratorExit(BaseException):
3455    """ Request that a generator exit. """
3456    def __init__(self, *args, **kwargs): # real signature unknown
3457        pass
3458
3459    @staticmethod # known case of __new__
3460    def __new__(*args, **kwargs): # real signature unknown
3461        """ Create and return a new object.  See help(type) for accurate signature. """
3462        pass
3463
3464
3465class ImportError(Exception):
3466    """ Import can't find module, or can't find name in module. """
3467    def __init__(self, *args, **kwargs): # real signature unknown
3468        pass
3469
3470    def __reduce__(self, *args, **kwargs): # real signature unknown
3471        pass
3472
3473    def __str__(self, *args, **kwargs): # real signature unknown
3474        """ Return str(self). """
3475        pass
3476
3477    msg = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3478    """exception message"""
3479
3480    name = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3481    """module name"""
3482
3483    path = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3484    """module path"""
3485
3486
3487
3488class ImportWarning(Warning):
3489    """ Base class for warnings about probable mistakes in module imports """
3490    def __init__(self, *args, **kwargs): # real signature unknown
3491        pass
3492
3493    @staticmethod # known case of __new__
3494    def __new__(*args, **kwargs): # real signature unknown
3495        """ Create and return a new object.  See help(type) for accurate signature. """
3496        pass
3497
3498
3499class SyntaxError(Exception):
3500    """ Invalid syntax. """
3501    def __init__(self, *args, **kwargs): # real signature unknown
3502        pass
3503
3504    def __str__(self, *args, **kwargs): # real signature unknown
3505        """ Return str(self). """
3506        pass
3507
3508    filename = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3509    """exception filename"""
3510
3511    lineno = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3512    """exception lineno"""
3513
3514    msg = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3515    """exception msg"""
3516
3517    offset = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3518    """exception offset"""
3519
3520    print_file_and_line = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3521    """exception print_file_and_line"""
3522
3523    text = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3524    """exception text"""
3525
3526
3527
3528class IndentationError(SyntaxError):
3529    """ Improper indentation. """
3530    def __init__(self, *args, **kwargs): # real signature unknown
3531        pass
3532
3533
3534class LookupError(Exception):
3535    """ Base class for lookup errors. """
3536    def __init__(self, *args, **kwargs): # real signature unknown
3537        pass
3538
3539    @staticmethod # known case of __new__
3540    def __new__(*args, **kwargs): # real signature unknown
3541        """ Create and return a new object.  See help(type) for accurate signature. """
3542        pass
3543
3544
3545class IndexError(LookupError):
3546    """ Sequence index out of range. """
3547    def __init__(self, *args, **kwargs): # real signature unknown
3548        pass
3549
3550    @staticmethod # known case of __new__
3551    def __new__(*args, **kwargs): # real signature unknown
3552        """ Create and return a new object.  See help(type) for accurate signature. """
3553        pass
3554
3555
3556class InterruptedError(OSError):
3557    """ Interrupted by signal. """
3558    def __init__(self, *args, **kwargs): # real signature unknown
3559        pass
3560
3561
3562class IsADirectoryError(OSError):
3563    """ Operation doesn't work on directories. """
3564    def __init__(self, *args, **kwargs): # real signature unknown
3565        pass
3566
3567
3568class KeyboardInterrupt(BaseException):
3569    """ Program interrupted by user. """
3570    def __init__(self, *args, **kwargs): # real signature unknown
3571        pass
3572
3573    @staticmethod # known case of __new__
3574    def __new__(*args, **kwargs): # real signature unknown
3575        """ Create and return a new object.  See help(type) for accurate signature. """
3576        pass
3577
3578
3579class KeyError(LookupError):
3580    """ Mapping key not found. """
3581    def __init__(self, *args, **kwargs): # real signature unknown
3582        pass
3583
3584    def __str__(self, *args, **kwargs): # real signature unknown
3585        """ Return str(self). """
3586        pass
3587
3588
3589class list(object):
3590    """
3591    list() -> new empty list
3592    list(iterable) -> new list initialized from iterable's items
3593    """
3594    def append(self, p_object): # real signature unknown; restored from __doc__
3595        """ L.append(object) -> None -- append object to end """
3596        pass
3597
3598    def clear(self): # real signature unknown; restored from __doc__
3599        """ L.clear() -> None -- remove all items from L """
3600        pass
3601
3602    def copy(self): # real signature unknown; restored from __doc__
3603        """ L.copy() -> list -- a shallow copy of L """
3604        return []
3605
3606    def count(self, value): # real signature unknown; restored from __doc__
3607        """ L.count(value) -> integer -- return number of occurrences of value """
3608        return 0
3609
3610    def extend(self, iterable): # real signature unknown; restored from __doc__
3611        """ L.extend(iterable) -> None -- extend list by appending elements from the iterable """
3612        pass
3613
3614    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
3615        """
3616        L.index(value, [start, [stop]]) -> integer -- return first index of value.
3617        Raises ValueError if the value is not present.
3618        """
3619        return 0
3620
3621    def insert(self, index, p_object): # real signature unknown; restored from __doc__
3622        """ L.insert(index, object) -- insert object before index """
3623        pass
3624
3625    def pop(self, index=None): # real signature unknown; restored from __doc__
3626        """
3627        L.pop([index]) -> item -- remove and return item at index (default last).
3628        Raises IndexError if list is empty or index is out of range.
3629        """
3630        pass
3631
3632    def remove(self, value): # real signature unknown; restored from __doc__
3633        """
3634        L.remove(value) -> None -- remove first occurrence of value.
3635        Raises ValueError if the value is not present.
3636        """
3637        pass
3638
3639    def reverse(self): # real signature unknown; restored from __doc__
3640        """ L.reverse() -- reverse *IN PLACE* """
3641        pass
3642
3643    def sort(self, key=None, reverse=False): # real signature unknown; restored from __doc__
3644        """ L.sort(key=None, reverse=False) -> None -- stable sort *IN PLACE* """
3645        pass
3646
3647    def __add__(self, *args, **kwargs): # real signature unknown
3648        """ Return self+value. """
3649        pass
3650
3651    def __contains__(self, *args, **kwargs): # real signature unknown
3652        """ Return key in self. """
3653        pass
3654
3655    def __delitem__(self, *args, **kwargs): # real signature unknown
3656        """ Delete self[key]. """
3657        pass
3658
3659    def __eq__(self, *args, **kwargs): # real signature unknown
3660        """ Return self==value. """
3661        pass
3662
3663    def __getattribute__(self, *args, **kwargs): # real signature unknown
3664        """ Return getattr(self, name). """
3665        pass
3666
3667    def __getitem__(self, y): # real signature unknown; restored from __doc__
3668        """ x.__getitem__(y) <==> x[y] """
3669        pass
3670
3671    def __ge__(self, *args, **kwargs): # real signature unknown
3672        """ Return self>=value. """
3673        pass
3674
3675    def __gt__(self, *args, **kwargs): # real signature unknown
3676        """ Return self>value. """
3677        pass
3678
3679    def __iadd__(self, *args, **kwargs): # real signature unknown
3680        """ Implement self+=value. """
3681        pass
3682
3683    def __imul__(self, *args, **kwargs): # real signature unknown
3684        """ Implement self*=value. """
3685        pass
3686
3687    def __init__(self, seq=()): # known special case of list.__init__
3688        """
3689        list() -> new empty list
3690        list(iterable) -> new list initialized from iterable's items
3691        # (copied from class doc)
3692        """
3693        pass
3694
3695    def __iter__(self, *args, **kwargs): # real signature unknown
3696        """ Implement iter(self). """
3697        pass
3698
3699    def __len__(self, *args, **kwargs): # real signature unknown
3700        """ Return len(self). """
3701        pass
3702
3703    def __le__(self, *args, **kwargs): # real signature unknown
3704        """ Return self<=value. """
3705        pass
3706
3707    def __lt__(self, *args, **kwargs): # real signature unknown
3708        """ Return self<value. """
3709        pass
3710
3711    def __mul__(self, *args, **kwargs): # real signature unknown
3712        """ Return self*value.n """
3713        pass
3714
3715    @staticmethod # known case of __new__
3716    def __new__(*args, **kwargs): # real signature unknown
3717        """ Create and return a new object.  See help(type) for accurate signature. """
3718        pass
3719
3720    def __ne__(self, *args, **kwargs): # real signature unknown
3721        """ Return self!=value. """
3722        pass
3723
3724    def __repr__(self, *args, **kwargs): # real signature unknown
3725        """ Return repr(self). """
3726        pass
3727
3728    def __reversed__(self): # real signature unknown; restored from __doc__
3729        """ L.__reversed__() -- return a reverse iterator over the list """
3730        pass
3731
3732    def __rmul__(self, *args, **kwargs): # real signature unknown
3733        """ Return self*value. """
3734        pass
3735
3736    def __setitem__(self, *args, **kwargs): # real signature unknown
3737        """ Set self[key] to value. """
3738        pass
3739
3740    def __sizeof__(self): # real signature unknown; restored from __doc__
3741        """ L.__sizeof__() -- size of L in memory, in bytes """
3742        pass
3743
3744    __hash__ = None
3745
3746
3747class map(object):
3748    """
3749    map(func, *iterables) --> map object
3750    
3751    Make an iterator that computes the function using arguments from
3752    each of the iterables.  Stops when the shortest iterable is exhausted.
3753    """
3754    def __getattribute__(self, *args, **kwargs): # real signature unknown
3755        """ Return getattr(self, name). """
3756        pass
3757
3758    def __init__(self, func, *iterables): # real signature unknown; restored from __doc__
3759        pass
3760
3761    def __iter__(self, *args, **kwargs): # real signature unknown
3762        """ Implement iter(self). """
3763        pass
3764
3765    @staticmethod # known case of __new__
3766    def __new__(*args, **kwargs): # real signature unknown
3767        """ Create and return a new object.  See help(type) for accurate signature. """
3768        pass
3769
3770    def __next__(self, *args, **kwargs): # real signature unknown
3771        """ Implement next(self). """
3772        pass
3773
3774    def __reduce__(self, *args, **kwargs): # real signature unknown
3775        """ Return state information for pickling. """
3776        pass
3777
3778
3779class MemoryError(Exception):
3780    """ Out of memory. """
3781    def __init__(self, *args, **kwargs): # real signature unknown
3782        pass
3783
3784    @staticmethod # known case of __new__
3785    def __new__(*args, **kwargs): # real signature unknown
3786        """ Create and return a new object.  See help(type) for accurate signature. """
3787        pass
3788
3789
3790class memoryview(object):
3791    """ Create a new memoryview object which references the given object. """
3792    def cast(self, *args, **kwargs): # real signature unknown
3793        """ Cast a memoryview to a new format or shape. """
3794        pass
3795
3796    def hex(self, *args, **kwargs): # real signature unknown
3797        """ Return the data in the buffer as a string of hexadecimal numbers. """
3798        pass
3799
3800    def release(self, *args, **kwargs): # real signature unknown
3801        """ Release the underlying buffer exposed by the memoryview object. """
3802        pass
3803
3804    def tobytes(self, *args, **kwargs): # real signature unknown
3805        """ Return the data in the buffer as a byte string. """
3806        pass
3807
3808    def tolist(self, *args, **kwargs): # real signature unknown
3809        """ Return the data in the buffer as a list of elements. """
3810        pass
3811
3812    def __delitem__(self, *args, **kwargs): # real signature unknown
3813        """ Delete self[key]. """
3814        pass
3815
3816    def __enter__(self, *args, **kwargs): # real signature unknown
3817        pass
3818
3819    def __eq__(self, *args, **kwargs): # real signature unknown
3820        """ Return self==value. """
3821        pass
3822
3823    def __exit__(self, *args, **kwargs): # real signature unknown
3824        pass
3825
3826    def __getattribute__(self, *args, **kwargs): # real signature unknown
3827        """ Return getattr(self, name). """
3828        pass
3829
3830    def __getitem__(self, *args, **kwargs): # real signature unknown
3831        """ Return self[key]. """
3832        pass
3833
3834    def __ge__(self, *args, **kwargs): # real signature unknown
3835        """ Return self>=value. """
3836        pass
3837
3838    def __gt__(self, *args, **kwargs): # real signature unknown
3839        """ Return self>value. """
3840        pass
3841
3842    def __hash__(self, *args, **kwargs): # real signature unknown
3843        """ Return hash(self). """
3844        pass
3845
3846    def __init__(self, *args, **kwargs): # real signature unknown
3847        pass
3848
3849    def __len__(self, *args, **kwargs): # real signature unknown
3850        """ Return len(self). """
3851        pass
3852
3853    def __le__(self, *args, **kwargs): # real signature unknown
3854        """ Return self<=value. """
3855        pass
3856
3857    def __lt__(self, *args, **kwargs): # real signature unknown
3858        """ Return self<value. """
3859        pass
3860
3861    @staticmethod # known case of __new__
3862    def __new__(*args, **kwargs): # real signature unknown
3863        """ Create and return a new object.  See help(type) for accurate signature. """
3864        pass
3865
3866    def __ne__(self, *args, **kwargs): # real signature unknown
3867        """ Return self!=value. """
3868        pass
3869
3870    def __repr__(self, *args, **kwargs): # real signature unknown
3871        """ Return repr(self). """
3872        pass
3873
3874    def __setitem__(self, *args, **kwargs): # real signature unknown
3875        """ Set self[key] to value. """
3876        pass
3877
3878    contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3879    """A bool indicating whether the memory is contiguous."""
3880
3881    c_contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3882    """A bool indicating whether the memory is C contiguous."""
3883
3884    format = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3885    """A string containing the format (in struct module style)
3886 for each element in the view."""
3887
3888    f_contiguous = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3889    """A bool indicating whether the memory is Fortran contiguous."""
3890
3891    itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3892    """The size in bytes of each element of the memoryview."""
3893
3894    nbytes = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3895    """The amount of space in bytes that the array would use in
3896 a contiguous representation."""
3897
3898    ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3899    """An integer indicating how many dimensions of a multi-dimensional
3900 array the memory represents."""
3901
3902    obj = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3903    """The underlying object of the memoryview."""
3904
3905    readonly = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3906    """A bool indicating whether the memory is read only."""
3907
3908    shape = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3909    """A tuple of ndim integers giving the shape of the memory
3910 as an N-dimensional array."""
3911
3912    strides = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3913    """A tuple of ndim integers giving the size in bytes to access
3914 each element for each dimension of the array."""
3915
3916    suboffsets = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3917    """A tuple of integers used internally for PIL-style arrays."""
3918
3919
3920
3921class ModuleNotFoundError(ImportError):
3922    """ Module not found. """
3923    def __init__(self, *args, **kwargs): # real signature unknown
3924        pass
3925
3926
3927class NameError(Exception):
3928    """ Name not found globally. """
3929    def __init__(self, *args, **kwargs): # real signature unknown
3930        pass
3931
3932    @staticmethod # known case of __new__
3933    def __new__(*args, **kwargs): # real signature unknown
3934        """ Create and return a new object.  See help(type) for accurate signature. """
3935        pass
3936
3937
3938class NotADirectoryError(OSError):
3939    """ Operation only works on directories. """
3940    def __init__(self, *args, **kwargs): # real signature unknown
3941        pass
3942
3943
3944class RuntimeError(Exception):
3945    """ Unspecified run-time error. """
3946    def __init__(self, *args, **kwargs): # real signature unknown
3947        pass
3948
3949    @staticmethod # known case of __new__
3950    def __new__(*args, **kwargs): # real signature unknown
3951        """ Create and return a new object.  See help(type) for accurate signature. """
3952        pass
3953
3954
3955class NotImplementedError(RuntimeError):
3956    """ Method or function hasn't been implemented yet. """
3957    def __init__(self, *args, **kwargs): # real signature unknown
3958        pass
3959
3960    @staticmethod # known case of __new__
3961    def __new__(*args, **kwargs): # real signature unknown
3962        """ Create and return a new object.  See help(type) for accurate signature. """
3963        pass
3964
3965
3966class OverflowError(ArithmeticError):
3967    """ Result too large to be represented. """
3968    def __init__(self, *args, **kwargs): # real signature unknown
3969        pass
3970
3971    @staticmethod # known case of __new__
3972    def __new__(*args, **kwargs): # real signature unknown
3973        """ Create and return a new object.  See help(type) for accurate signature. """
3974        pass
3975
3976
3977class PendingDeprecationWarning(Warning):
3978    """
3979    Base class for warnings about features which will be deprecated
3980    in the future.
3981    """
3982    def __init__(self, *args, **kwargs): # real signature unknown
3983        pass
3984
3985    @staticmethod # known case of __new__
3986    def __new__(*args, **kwargs): # real signature unknown
3987        """ Create and return a new object.  See help(type) for accurate signature. """
3988        pass
3989
3990
3991class PermissionError(OSError):
3992    """ Not enough permissions. """
3993    def __init__(self, *args, **kwargs): # real signature unknown
3994        pass
3995
3996
3997class ProcessLookupError(OSError):
3998    """ Process not found. """
3999    def __init__(self, *args, **kwargs): # real signature unknown
4000        pass
4001
4002
4003class property(object):
4004    """
4005    property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
4006    
4007    fget is a function to be used for getting an attribute value, and likewise
4008    fset is a function for setting, and fdel a function for del'ing, an
4009    attribute.  Typical use is to define a managed attribute x:
4010    
4011    class C(object):
4012        def getx(self): return self._x
4013        def setx(self, value): self._x = value
4014        def delx(self): del self._x
4015        x = property(getx, setx, delx, "I'm the 'x' property.")
4016    
4017    Decorators make defining new properties or modifying existing ones easy:
4018    
4019    class C(object):
4020        @property
4021        def x(self):
4022            "I am the 'x' property."
4023            return self._x
4024        @x.setter
4025        def x(self, value):
4026            self._x = value
4027        @x.deleter
4028        def x(self):
4029            del self._x
4030    """
4031    def deleter(self, *args, **kwargs): # real signature unknown
4032        """ Descriptor to change the deleter on a property. """
4033        pass
4034
4035    def getter(self, *args, **kwargs): # real signature unknown
4036        """ Descriptor to change the getter on a property. """
4037        pass
4038
4039    def setter(self, *args, **kwargs): # real signature unknown
4040        """ Descriptor to change the setter on a property. """
4041        pass
4042
4043    def __delete__(self, *args, **kwargs): # real signature unknown
4044        """ Delete an attribute of instance. """
4045        pass
4046
4047    def __getattribute__(self, *args, **kwargs): # real signature unknown
4048        """ Return getattr(self, name). """
4049        pass
4050
4051    def __get__(self, *args, **kwargs): # real signature unknown
4052        """ Return an attribute of instance, which is of type owner. """
4053        pass
4054
4055    def __init__(self, fget=None, fset=None, fdel=None, doc=None): # known special case of property.__init__
4056        """
4057        property(fget=None, fset=None, fdel=None, doc=None) -> property attribute
4058        
4059        fget is a function to be used for getting an attribute value, and likewise
4060        fset is a function for setting, and fdel a function for del'ing, an
4061        attribute.  Typical use is to define a managed attribute x:
4062        
4063        class C(object):
4064            def getx(self): return self._x
4065            def setx(self, value): self._x = value
4066            def delx(self): del self._x
4067            x = property(getx, setx, delx, "I'm the 'x' property.")
4068        
4069        Decorators make defining new properties or modifying existing ones easy:
4070        
4071        class C(object):
4072            @property
4073            def x(self):
4074                "I am the 'x' property."
4075                return self._x
4076            @x.setter
4077            def x(self, value):
4078                self._x = value
4079            @x.deleter
4080            def x(self):
4081                del self._x
4082        
4083        # (copied from class doc)
4084        """
4085        pass
4086
4087    @staticmethod # known case of __new__
4088    def __new__(*args, **kwargs): # real signature unknown
4089        """ Create and return a new object.  See help(type) for accurate signature. """
4090        pass
4091
4092    def __set__(self, *args, **kwargs): # real signature unknown
4093        """ Set an attribute of instance to value. """
4094        pass
4095
4096    fdel = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4097
4098    fget = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4099
4100    fset = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4101
4102    __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4103
4104
4105
4106class range(object):
4107    """
4108    range(stop) -> range object
4109    range(start, stop[, step]) -> range object
4110    
4111    Return an object that produces a sequence of integers from start (inclusive)
4112    to stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.
4113    start defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.
4114    These are exactly the valid indices for a list of 4 elements.
4115    When step is given, it specifies the increment (or decrement).
4116    """
4117    def count(self, value): # real signature unknown; restored from __doc__
4118        """ rangeobject.count(value) -> integer -- return number of occurrences of value """
4119        return 0
4120
4121    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
4122        """
4123        rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
4124        Raise ValueError if the value is not present.
4125        """
4126        return 0
4127
4128    def __bool__(self, *args, **kwargs): # real signature unknown
4129        """ self != 0 """
4130        pass
4131
4132    def __contains__(self, *args, **kwargs): # real signature unknown
4133        """ Return key in self. """
4134        pass
4135
4136    def __eq__(self, *args, **kwargs): # real signature unknown
4137        """ Return self==value. """
4138        pass
4139
4140    def __getattribute__(self, *args, **kwargs): # real signature unknown
4141        """ Return getattr(self, name). """
4142        pass
4143
4144    def __getitem__(self, *args, **kwargs): # real signature unknown
4145        """ Return self[key]. """
4146        pass
4147
4148    def __ge__(self, *args, **kwargs): # real signature unknown
4149        """ Return self>=value. """
4150        pass
4151
4152    def __gt__(self, *args, **kwargs): # real signature unknown
4153        """ Return self>value. """
4154        pass
4155
4156    def __hash__(self, *args, **kwargs): # real signature unknown
4157        """ Return hash(self). """
4158        pass
4159
4160    def __init__(self, stop): # real signature unknown; restored from __doc__
4161        pass
4162
4163    def __iter__(self, *args, **kwargs): # real signature unknown
4164        """ Implement iter(self). """
4165        pass
4166
4167    def __len__(self, *args, **kwargs): # real signature unknown
4168        """ Return len(self). """
4169        pass
4170
4171    def __le__(self, *args, **kwargs): # real signature unknown
4172        """ Return self<=value. """
4173        pass
4174
4175    def __lt__(self, *args, **kwargs): # real signature unknown
4176        """ Return self<value. """
4177        pass
4178
4179    @staticmethod # known case of __new__
4180    def __new__(*args, **kwargs): # real signature unknown
4181        """ Create and return a new object.  See help(type) for accurate signature. """
4182        pass
4183
4184    def __ne__(self, *args, **kwargs): # real signature unknown
4185        """ Return self!=value. """
4186        pass
4187
4188    def __reduce__(self, *args, **kwargs): # real signature unknown
4189        pass
4190
4191    def __repr__(self, *args, **kwargs): # real signature unknown
4192        """ Return repr(self). """
4193        pass
4194
4195    def __reversed__(self, *args, **kwargs): # real signature unknown
4196        """ Return a reverse iterator. """
4197        pass
4198
4199    start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4200
4201    step = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4202
4203    stop = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4204
4205
4206
4207class RecursionError(RuntimeError):
4208    """ Recursion limit exceeded. """
4209    def __init__(self, *args, **kwargs): # real signature unknown
4210        pass
4211
4212    @staticmethod # known case of __new__
4213    def __new__(*args, **kwargs): # real signature unknown
4214        """ Create and return a new object.  See help(type) for accurate signature. """
4215        pass
4216
4217
4218class ReferenceError(Exception):
4219    """ Weak ref proxy used after referent went away. """
4220    def __init__(self, *args, **kwargs): # real signature unknown
4221        pass
4222
4223    @staticmethod # known case of __new__
4224    def __new__(*args, **kwargs): # real signature unknown
4225        """ Create and return a new object.  See help(type) for accurate signature. """
4226        pass
4227
4228
4229class ResourceWarning(Warning):
4230    """ Base class for warnings about resource usage. """
4231    def __init__(self, *args, **kwargs): # real signature unknown
4232        pass
4233
4234    @staticmethod # known case of __new__
4235    def __new__(*args, **kwargs): # real signature unknown
4236        """ Create and return a new object.  See help(type) for accurate signature. """
4237        pass
4238
4239
4240class reversed(object):
4241    """
4242    reversed(sequence) -> reverse iterator over values of the sequence
4243    
4244    Return a reverse iterator
4245    """
4246    def __getattribute__(self, *args, **kwargs): # real signature unknown
4247        """ Return getattr(self, name). """
4248        pass
4249
4250    def __init__(self, sequence): # real signature unknown; restored from __doc__
4251        pass
4252
4253    def __iter__(self, *args, **kwargs): # real signature unknown
4254        """ Implement iter(self). """
4255        pass
4256
4257    def __length_hint__(self, *args, **kwargs): # real signature unknown
4258        """ Private method returning an estimate of len(list(it)). """
4259        pass
4260
4261    @staticmethod # known case of __new__
4262    def __new__(*args, **kwargs): # real signature unknown
4263        """ Create and return a new object.  See help(type) for accurate signature. """
4264        pass
4265
4266    def __next__(self, *args, **kwargs): # real signature unknown
4267        """ Implement next(self). """
4268        pass
4269
4270    def __reduce__(self, *args, **kwargs): # real signature unknown
4271        """ Return state information for pickling. """
4272        pass
4273
4274    def __setstate__(self, *args, **kwargs): # real signature unknown
4275        """ Set state information for unpickling. """
4276        pass
4277
4278
4279class RuntimeWarning(Warning):
4280    """ Base class for warnings about dubious runtime behavior. """
4281    def __init__(self, *args, **kwargs): # real signature unknown
4282        pass
4283
4284    @staticmethod # known case of __new__
4285    def __new__(*args, **kwargs): # real signature unknown
4286        """ Create and return a new object.  See help(type) for accurate signature. """
4287        pass
4288
4289
4290class set(object):
4291    """
4292    set() -> new empty set object
4293    set(iterable) -> new set object
4294    
4295    Build an unordered collection of unique elements.
4296    """
4297    def add(self, *args, **kwargs): # real signature unknown
4298        """
4299        Add an element to a set.
4300        
4301        This has no effect if the element is already present.
4302        """
4303        pass
4304
4305    def clear(self, *args, **kwargs): # real signature unknown
4306        """ Remove all elements from this set. """
4307        pass
4308
4309    def copy(self, *args, **kwargs): # real signature unknown
4310        """ Return a shallow copy of a set. """
4311        pass
4312
4313    def difference(self, *args, **kwargs): # real signature unknown
4314        """
4315        Return the difference of two or more sets as a new set.
4316        
4317        (i.e. all elements that are in this set but not the others.)
4318        """
4319        pass
4320
4321    def difference_update(self, *args, **kwargs): # real signature unknown
4322        """ Remove all elements of another set from this set. """
4323        pass
4324
4325    def discard(self, *args, **kwargs): # real signature unknown
4326        """
4327        Remove an element from a set if it is a member.
4328        
4329        If the element is not a member, do nothing.
4330        """
4331        pass
4332
4333    def intersection(self, *args, **kwargs): # real signature unknown
4334        """
4335        Return the intersection of two sets as a new set.
4336        
4337        (i.e. all elements that are in both sets.)
4338        """
4339        pass
4340
4341    def intersection_update(self, *args, **kwargs): # real signature unknown
4342        """ Update a set with the intersection of itself and another. """
4343        pass
4344
4345    def isdisjoint(self, *args, **kwargs): # real signature unknown
4346        """ Return True if two sets have a null intersection. """
4347        pass
4348
4349    def issubset(self, *args, **kwargs): # real signature unknown
4350        """ Report whether another set contains this set. """
4351        pass
4352
4353    def issuperset(self, *args, **kwargs): # real signature unknown
4354        """ Report whether this set contains another set. """
4355        pass
4356
4357    def pop(self, *args, **kwargs): # real signature unknown
4358        """
4359        Remove and return an arbitrary set element.
4360        Raises KeyError if the set is empty.
4361        """
4362        pass
4363
4364    def remove(self, *args, **kwargs): # real signature unknown
4365        """
4366        Remove an element from a set; it must be a member.
4367        
4368        If the element is not a member, raise a KeyError.
4369        """
4370        pass
4371
4372    def symmetric_difference(self, *args, **kwargs): # real signature unknown
4373        """
4374        Return the symmetric difference of two sets as a new set.
4375        
4376        (i.e. all elements that are in exactly one of the sets.)
4377        """
4378        pass
4379
4380    def symmetric_difference_update(self, *args, **kwargs): # real signature unknown
4381        """ Update a set with the symmetric difference of itself and another. """
4382        pass
4383
4384    def union(self, *args, **kwargs): # real signature unknown
4385        """
4386        Return the union of sets as a new set.
4387        
4388        (i.e. all elements that are in either set.)
4389        """
4390        pass
4391
4392    def update(self, *args, **kwargs): # real signature unknown
4393        """ Update a set with the union of itself and others. """
4394        pass
4395
4396    def __and__(self, *args, **kwargs): # real signature unknown
4397        """ Return self&value. """
4398        pass
4399
4400    def __contains__(self, y): # real signature unknown; restored from __doc__
4401        """ x.__contains__(y) <==> y in x. """
4402        pass
4403
4404    def __eq__(self, *args, **kwargs): # real signature unknown
4405        """ Return self==value. """
4406        pass
4407
4408    def __getattribute__(self, *args, **kwargs): # real signature unknown
4409        """ Return getattr(self, name). """
4410        pass
4411
4412    def __ge__(self, *args, **kwargs): # real signature unknown
4413        """ Return self>=value. """
4414        pass
4415
4416    def __gt__(self, *args, **kwargs): # real signature unknown
4417        """ Return self>value. """
4418        pass
4419
4420    def __iand__(self, *args, **kwargs): # real signature unknown
4421        """ Return self&=value. """
4422        pass
4423
4424    def __init__(self, seq=()): # known special case of set.__init__
4425        """
4426        set() -> new empty set object
4427        set(iterable) -> new set object
4428        
4429        Build an unordered collection of unique elements.
4430        # (copied from class doc)
4431        """
4432        pass
4433
4434    def __ior__(self, *args, **kwargs): # real signature unknown
4435        """ Return self|=value. """
4436        pass
4437
4438    def __isub__(self, *args, **kwargs): # real signature unknown
4439        """ Return self-=value. """
4440        pass
4441
4442    def __iter__(self, *args, **kwargs): # real signature unknown
4443        """ Implement iter(self). """
4444        pass
4445
4446    def __ixor__(self, *args, **kwargs): # real signature unknown
4447        """ Return self^=value. """
4448        pass
4449
4450    def __len__(self, *args, **kwargs): # real signature unknown
4451        """ Return len(self). """
4452        pass
4453
4454    def __le__(self, *args, **kwargs): # real signature unknown
4455        """ Return self<=value. """
4456        pass
4457
4458    def __lt__(self, *args, **kwargs): # real signature unknown
4459        """ Return self<value. """
4460        pass
4461
4462    @staticmethod # known case of __new__
4463    def __new__(*args, **kwargs): # real signature unknown
4464        """ Create and return a new object.  See help(type) for accurate signature. """
4465        pass
4466
4467    def __ne__(self, *args, **kwargs): # real signature unknown
4468        """ Return self!=value. """
4469        pass
4470
4471    def __or__(self, *args, **kwargs): # real signature unknown
4472        """ Return self|value. """
4473        pass
4474
4475    def __rand__(self, *args, **kwargs): # real signature unknown
4476        """ Return value&self. """
4477        pass
4478
4479    def __reduce__(self, *args, **kwargs): # real signature unknown
4480        """ Return state information for pickling. """
4481        pass
4482
4483    def __repr__(self, *args, **kwargs): # real signature unknown
4484        """ Return repr(self). """
4485        pass
4486
4487    def __ror__(self, *args, **kwargs): # real signature unknown
4488        """ Return value|self. """
4489        pass
4490
4491    def __rsub__(self, *args, **kwargs): # real signature unknown
4492        """ Return value-self. """
4493        pass
4494
4495    def __rxor__(self, *args, **kwargs): # real signature unknown
4496        """ Return value^self. """
4497        pass
4498
4499    def __sizeof__(self): # real signature unknown; restored from __doc__
4500        """ S.__sizeof__() -> size of S in memory, in bytes """
4501        pass
4502
4503    def __sub__(self, *args, **kwargs): # real signature unknown
4504        """ Return self-value. """
4505        pass
4506
4507    def __xor__(self, *args, **kwargs): # real signature unknown
4508        """ Return self^value. """
4509        pass
4510
4511    __hash__ = None
4512
4513
4514class slice(object):
4515    """
4516    slice(stop)
4517    slice(start, stop[, step])
4518    
4519    Create a slice object.  This is used for extended slicing (e.g. a[0:10:2]).
4520    """
4521    def indices(self, len): # real signature unknown; restored from __doc__
4522        """
4523        S.indices(len) -> (start, stop, stride)
4524        
4525        Assuming a sequence of length len, calculate the start and stop
4526        indices, and the stride length of the extended slice described by
4527        S. Out of bounds indices are clipped in a manner consistent with the
4528        handling of normal slices.
4529        """
4530        pass
4531
4532    def __eq__(self, *args, **kwargs): # real signature unknown
4533        """ Return self==value. """
4534        pass
4535
4536    def __getattribute__(self, *args, **kwargs): # real signature unknown
4537        """ Return getattr(self, name). """
4538        pass
4539
4540    def __ge__(self, *args, **kwargs): # real signature unknown
4541        """ Return self>=value. """
4542        pass
4543
4544    def __gt__(self, *args, **kwargs): # real signature unknown
4545        """ Return self>value. """
4546        pass
4547
4548    def __init__(self, stop): # real signature unknown; restored from __doc__
4549        pass
4550
4551    def __le__(self, *args, **kwargs): # real signature unknown
4552        """ Return self<=value. """
4553        pass
4554
4555    def __lt__(self, *args, **kwargs): # real signature unknown
4556        """ Return self<value. """
4557        pass
4558
4559    @staticmethod # known case of __new__
4560    def __new__(*args, **kwargs): # real signature unknown
4561        """ Create and return a new object.  See help(type) for accurate signature. """
4562        pass
4563
4564    def __ne__(self, *args, **kwargs): # real signature unknown
4565        """ Return self!=value. """
4566        pass
4567
4568    def __reduce__(self, *args, **kwargs): # real signature unknown
4569        """ Return state information for pickling. """
4570        pass
4571
4572    def __repr__(self, *args, **kwargs): # real signature unknown
4573        """ Return repr(self). """
4574        pass
4575
4576    start = property(lambda self: 0)
4577    """:type: int"""
4578
4579    step = property(lambda self: 0)
4580    """:type: int"""
4581
4582    stop = property(lambda self: 0)
4583    """:type: int"""
4584
4585
4586    __hash__ = None
4587
4588
4589class staticmethod(object):
4590    """
4591    staticmethod(function) -> method
4592    
4593    Convert a function to be a static method.
4594    
4595    A static method does not receive an implicit first argument.
4596    To declare a static method, use this idiom:
4597    
4598         class C:
4599             @staticmethod
4600             def f(arg1, arg2, ...):
4601                 ...
4602    
4603    It can be called either on the class (e.g. C.f()) or on an instance
4604    (e.g. C().f()).  The instance is ignored except for its class.
4605    
4606    Static methods in Python are similar to those found in Java or C++.
4607    For a more advanced concept, see the classmethod builtin.
4608    """
4609    def __get__(self, *args, **kwargs): # real signature unknown
4610        """ Return an attribute of instance, which is of type owner. """
4611        pass
4612
4613    def __init__(self, function): # real signature unknown; restored from __doc__
4614        pass
4615
4616    @staticmethod # known case of __new__
4617    def __new__(*args, **kwargs): # real signature unknown
4618        """ Create and return a new object.  See help(type) for accurate signature. """
4619        pass
4620
4621    __func__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4622
4623    __isabstractmethod__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4624
4625
4626    __dict__ = None # (!) real value is ''
4627
4628
4629class StopAsyncIteration(Exception):
4630    """ Signal the end from iterator.__anext__(). """
4631    def __init__(self, *args, **kwargs): # real signature unknown
4632        pass
4633
4634    @staticmethod # known case of __new__
4635    def __new__(*args, **kwargs): # real signature unknown
4636        """ Create and return a new object.  See help(type) for accurate signature. """
4637        pass
4638
4639
4640class StopIteration(Exception):
4641    """ Signal the end from iterator.__next__(). """
4642    def __init__(self, *args, **kwargs): # real signature unknown
4643        pass
4644
4645    value = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4646    """generator return value"""
4647
4648
4649
4650class str(object):
4651    """
4652    str(object='') -> str
4653    str(bytes_or_buffer[, encoding[, errors]]) -> str
4654    
4655    Create a new string object from the given object. If encoding or
4656    errors is specified, then the object must expose a data buffer
4657    that will be decoded using the given encoding and error handler.
4658    Otherwise, returns the result of object.__str__() (if defined)
4659    or repr(object).
4660    encoding defaults to sys.getdefaultencoding().
4661    errors defaults to 'strict'.
4662    """
4663    def capitalize(self): # real signature unknown; restored from __doc__
4664        """
4665        S.capitalize() -> str
4666        
4667        Return a capitalized version of S, i.e. make the first character
4668        have upper case and the rest lower case.
4669        """
4670        return ""
4671
4672    def casefold(self): # real signature unknown; restored from __doc__
4673        """
4674        S.casefold() -> str
4675        
4676        Return a version of S suitable for caseless comparisons.
4677        """
4678        return ""
4679
4680    def center(self, width, fillchar=None): # real signature unknown; restored from __doc__
4681        """
4682        S.center(width[, fillchar]) -> str
4683        
4684        Return S centered in a string of length width. Padding is
4685        done using the specified fill character (default is a space)
4686        """
4687        return ""
4688
4689    def count(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4690        """
4691        S.count(sub[, start[, end]]) -> int
4692        
4693        Return the number of non-overlapping occurrences of substring sub in
4694        string S[start:end].  Optional arguments start and end are
4695        interpreted as in slice notation.
4696        """
4697        return 0
4698
4699    def encode(self, encoding='utf-8', errors='strict'): # real signature unknown; restored from __doc__
4700        """
4701        S.encode(encoding='utf-8', errors='strict') -> bytes
4702        
4703        Encode S using the codec registered for encoding. Default encoding
4704        is 'utf-8'. errors may be given to set a different error
4705        handling scheme. Default is 'strict' meaning that encoding errors raise
4706        a UnicodeEncodeError. Other possible values are 'ignore', 'replace' and
4707        'xmlcharrefreplace' as well as any other name registered with
4708        codecs.register_error that can handle UnicodeEncodeErrors.
4709        """
4710        return b""
4711
4712    def endswith(self, suffix, start=None, end=None): # real signature unknown; restored from __doc__
4713        """
4714        S.endswith(suffix[, start[, end]]) -> bool
4715        
4716        Return True if S ends with the specified suffix, False otherwise.
4717        With optional start, test S beginning at that position.
4718        With optional end, stop comparing S at that position.
4719        suffix can also be a tuple of strings to try.
4720        """
4721        return False
4722
4723    def expandtabs(self, tabsize=8): # real signature unknown; restored from __doc__
4724        """
4725        S.expandtabs(tabsize=8) -> str
4726        
4727        Return a copy of S where all tab characters are expanded using spaces.
4728        If tabsize is not given, a tab size of 8 characters is assumed.
4729        """
4730        return ""
4731
4732    def find(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4733        """
4734        S.find(sub[, start[, end]]) -> int
4735        
4736        Return the lowest index in S where substring sub is found,
4737        such that sub is contained within S[start:end].  Optional
4738        arguments start and end are interpreted as in slice notation.
4739        
4740        Return -1 on failure.
4741        """
4742        return 0
4743
4744    def format(self, *args, **kwargs): # known special case of str.format
4745        """
4746        S.format(*args, **kwargs) -> str
4747        
4748        Return a formatted version of S, using substitutions from args and kwargs.
4749        The substitutions are identified by braces ('{' and '}').
4750        """
4751        pass
4752
4753    def format_map(self, mapping): # real signature unknown; restored from __doc__
4754        """
4755        S.format_map(mapping) -> str
4756        
4757        Return a formatted version of S, using substitutions from mapping.
4758        The substitutions are identified by braces ('{' and '}').
4759        """
4760        return ""
4761
4762    def index(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4763        """
4764        S.index(sub[, start[, end]]) -> int
4765        
4766        Return the lowest index in S where substring sub is found, 
4767        such that sub is contained within S[start:end].  Optional
4768        arguments start and end are interpreted as in slice notation.
4769        
4770        Raises ValueError when the substring is not found.
4771        """
4772        return 0
4773
4774    def isalnum(self): # real signature unknown; restored from __doc__
4775        """
4776        S.isalnum() -> bool
4777        
4778        Return True if all characters in S are alphanumeric
4779        and there is at least one character in S, False otherwise.
4780        """
4781        return False
4782
4783    def isalpha(self): # real signature unknown; restored from __doc__
4784        """
4785        S.isalpha() -> bool
4786        
4787        Return True if all characters in S are alphabetic
4788        and there is at least one character in S, False otherwise.
4789        """
4790        return False
4791
4792    def isdecimal(self): # real signature unknown; restored from __doc__
4793        """
4794        S.isdecimal() -> bool
4795        
4796        Return True if there are only decimal characters in S,
4797        False otherwise.
4798        """
4799        return False
4800
4801    def isdigit(self): # real signature unknown; restored from __doc__
4802        """
4803        S.isdigit() -> bool
4804        
4805        Return True if all characters in S are digits
4806        and there is at least one character in S, False otherwise.
4807        """
4808        return False
4809
4810    def isidentifier(self): # real signature unknown; restored from __doc__
4811        """
4812        S.isidentifier() -> bool
4813        
4814        Return True if S is a valid identifier according
4815        to the language definition.
4816        
4817        Use keyword.iskeyword() to test for reserved identifiers
4818        such as "def" and "class".
4819        """
4820        return False
4821
4822    def islower(self): # real signature unknown; restored from __doc__
4823        """
4824        S.islower() -> bool
4825        
4826        Return True if all cased characters in S are lowercase and there is
4827        at least one cased character in S, False otherwise.
4828        """
4829        return False
4830
4831    def isnumeric(self): # real signature unknown; restored from __doc__
4832        """
4833        S.isnumeric() -> bool
4834        
4835        Return True if there are only numeric characters in S,
4836        False otherwise.
4837        """
4838        return False
4839
4840    def isprintable(self): # real signature unknown; restored from __doc__
4841        """
4842        S.isprintable() -> bool
4843        
4844        Return True if all characters in S are considered
4845        printable in repr() or S is empty, False otherwise.
4846        """
4847        return False
4848
4849    def isspace(self): # real signature unknown; restored from __doc__
4850        """
4851        S.isspace() -> bool
4852        
4853        Return True if all characters in S are whitespace
4854        and there is at least one character in S, False otherwise.
4855        """
4856        return False
4857
4858    def istitle(self): # real signature unknown; restored from __doc__
4859        """
4860        S.istitle() -> bool
4861        
4862        Return True if S is a titlecased string and there is at least one
4863        character in S, i.e. upper- and titlecase characters may only
4864        follow uncased characters and lowercase characters only cased ones.
4865        Return False otherwise.
4866        """
4867        return False
4868
4869    def isupper(self): # real signature unknown; restored from __doc__
4870        """
4871        S.isupper() -> bool
4872        
4873        Return True if all cased characters in S are uppercase and there is
4874        at least one cased character in S, False otherwise.
4875        """
4876        return False
4877
4878    def join(self, iterable): # real signature unknown; restored from __doc__
4879        """
4880        S.join(iterable) -> str
4881        
4882        Return a string which is the concatenation of the strings in the
4883        iterable.  The separator between elements is S.
4884        """
4885        return ""
4886
4887    def ljust(self, width, fillchar=None): # real signature unknown; restored from __doc__
4888        """
4889        S.ljust(width[, fillchar]) -> str
4890        
4891        Return S left-justified in a Unicode string of length width. Padding is
4892        done using the specified fill character (default is a space).
4893        """
4894        return ""
4895
4896    def lower(self): # real signature unknown; restored from __doc__
4897        """
4898        S.lower() -> str
4899        
4900        Return a copy of the string S converted to lowercase.
4901        """
4902        return ""
4903
4904    def lstrip(self, chars=None): # real signature unknown; restored from __doc__
4905        """
4906        S.lstrip([chars]) -> str
4907        
4908        Return a copy of the string S with leading whitespace removed.
4909        If chars is given and not None, remove characters in chars instead.
4910        """
4911        return ""
4912
4913    def maketrans(self, *args, **kwargs): # real signature unknown
4914        """
4915        Return a translation table usable for str.translate().
4916        
4917        If there is only one argument, it must be a dictionary mapping Unicode
4918        ordinals (integers) or characters to Unicode ordinals, strings or None.
4919        Character keys will be then converted to ordinals.
4920        If there are two arguments, they must be strings of equal length, and
4921        in the resulting dictionary, each character in x will be mapped to the
4922        character at the same position in y. If there is a third argument, it
4923        must be a string, whose characters will be mapped to None in the result.
4924        """
4925        pass
4926
4927    def partition(self, sep): # real signature unknown; restored from __doc__
4928        """
4929        S.partition(sep) -> (head, sep, tail)
4930        
4931        Search for the separator sep in S, and return the part before it,
4932        the separator itself, and the part after it.  If the separator is not
4933        found, return S and two empty strings.
4934        """
4935        pass
4936
4937    def replace(self, old, new, count=None): # real signature unknown; restored from __doc__
4938        """
4939        S.replace(old, new[, count]) -> str
4940        
4941        Return a copy of S with all occurrences of substring
4942        old replaced by new.  If the optional argument count is
4943        given, only the first count occurrences are replaced.
4944        """
4945        return ""
4946
4947    def rfind(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4948        """
4949        S.rfind(sub[, start[, end]]) -> int
4950        
4951        Return the highest index in S where substring sub is found,
4952        such that sub is contained within S[start:end].  Optional
4953        arguments start and end are interpreted as in slice notation.
4954        
4955        Return -1 on failure.
4956        """
4957        return 0
4958
4959    def rindex(self, sub, start=None, end=None): # real signature unknown; restored from __doc__
4960        """
4961        S.rindex(sub[, start[, end]]) -> int
4962        
4963        Return the highest index in S where substring sub is found,
4964        such that sub is contained within S[start:end].  Optional
4965        arguments start and end are interpreted as in slice notation.
4966        
4967        Raises ValueError when the substring is not found.
4968        """
4969        return 0
4970
4971    def rjust(self, width, fillchar=None): # real signature unknown; restored from __doc__
4972        """
4973        S.rjust(width[, fillchar]) -> str
4974        
4975        Return S right-justified in a string of length width. Padding is
4976        done using the specified fill character (default is a space).
4977        """
4978        return ""
4979
4980    def rpartition(self, sep): # real signature unknown; restored from __doc__
4981        """
4982        S.rpartition(sep) -> (head, sep, tail)
4983        
4984        Search for the separator sep in S, starting at the end of S, and return
4985        the part before it, the separator itself, and the part after it.  If the
4986        separator is not found, return two empty strings and S.
4987        """
4988        pass
4989
4990    def rsplit(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
4991        """
4992        S.rsplit(sep=None, maxsplit=-1) -> list of strings
4993        
4994        Return a list of the words in S, using sep as the
4995        delimiter string, starting at the end of the string and
4996        working to the front.  If maxsplit is given, at most maxsplit
4997        splits are done. If sep is not specified, any whitespace string
4998        is a separator.
4999        """
5000        return []
5001
5002    def rstrip(self, chars=None): # real signature unknown; restored from __doc__
5003        """
5004        S.rstrip([chars]) -> str
5005        
5006        Return a copy of the string S with trailing whitespace removed.
5007        If chars is given and not None, remove characters in chars instead.
5008        """
5009        return ""
5010
5011    def split(self, sep=None, maxsplit=-1): # real signature unknown; restored from __doc__
5012        """
5013        S.split(sep=None, maxsplit=-1) -> list of strings
5014        
5015        Return a list of the words in S, using sep as the
5016        delimiter string.  If maxsplit is given, at most maxsplit
5017        splits are done. If sep is not specified or is None, any
5018        whitespace string is a separator and empty strings are
5019        removed from the result.
5020        """
5021        return []
5022
5023    def splitlines(self, keepends=None): # real signature unknown; restored from __doc__
5024        """
5025        S.splitlines([keepends]) -> list of strings
5026        
5027        Return a list of the lines in S, breaking at line boundaries.
5028        Line breaks are not included in the resulting list unless keepends
5029        is given and true.
5030        """
5031        return []
5032
5033    def startswith(self, prefix, start=None, end=None): # real signature unknown; restored from __doc__
5034        """
5035        S.startswith(prefix[, start[, end]]) -> bool
5036        
5037        Return True if S starts with the specified prefix, False otherwise.
5038        With optional start, test S beginning at that position.
5039        With optional end, stop comparing S at that position.
5040        prefix can also be a tuple of strings to try.
5041        """
5042        return False
5043
5044    def strip(self, chars=None): # real signature unknown; restored from __doc__
5045        """
5046        S.strip([chars]) -> str
5047        
5048        Return a copy of the string S with leading and trailing
5049        whitespace removed.
5050        If chars is given and not None, remove characters in chars instead.
5051        """
5052        return ""
5053
5054    def swapcase(self): # real signature unknown; restored from __doc__
5055        """
5056        S.swapcase() -> str
5057        
5058        Return a copy of S with uppercase characters converted to lowercase
5059        and vice versa.
5060        """
5061        return ""
5062
5063    def title(self): # real signature unknown; restored from __doc__
5064        """
5065        S.title() -> str
5066        
5067        Return a titlecased version of S, i.e. words start with title case
5068        characters, all remaining cased characters have lower case.
5069        """
5070        return ""
5071
5072    def translate(self, table): # real signature unknown; restored from __doc__
5073        """
5074        S.translate(table) -> str
5075        
5076        Return a copy of the string S in which each character has been mapped
5077        through the given translation table. The table must implement
5078        lookup/indexing via __getitem__, for instance a dictionary or list,
5079        mapping Unicode ordinals to Unicode ordinals, strings, or None. If
5080        this operation raises LookupError, the character is left untouched.
5081        Characters mapped to None are deleted.
5082        """
5083        return ""
5084
5085    def upper(self): # real signature unknown; restored from __doc__
5086        """
5087        S.upper() -> str
5088        
5089        Return a copy of S converted to uppercase.
5090        """
5091        return ""
5092
5093    def zfill(self, width): # real signature unknown; restored from __doc__
5094        """
5095        S.zfill(width) -> str
5096        
5097        Pad a numeric string S with zeros on the left, to fill a field
5098        of the specified width. The string S is never truncated.
5099        """
5100        return ""
5101
5102    def __add__(self, *args, **kwargs): # real signature unknown
5103        """ Return self+value. """
5104        pass
5105
5106    def __contains__(self, *args, **kwargs): # real signature unknown
5107        """ Return key in self. """
5108        pass
5109
5110    def __eq__(self, *args, **kwargs): # real signature unknown
5111        """ Return self==value. """
5112        pass
5113
5114    def __format__(self, format_spec): # real signature unknown; restored from __doc__
5115        """
5116        S.__format__(format_spec) -> str
5117        
5118        Return a formatted version of S as described by format_spec.
5119        """
5120        return ""
5121
5122    def __getattribute__(self, *args, **kwargs): # real signature unknown
5123        """ Return getattr(self, name). """
5124        pass
5125
5126    def __getitem__(self, *args, **kwargs): # real signature unknown
5127        """ Return self[key]. """
5128        pass
5129
5130    def __getnewargs__(self, *args, **kwargs): # real signature unknown
5131        pass
5132
5133    def __ge__(self, *args, **kwargs): # real signature unknown
5134        """ Return self>=value. """
5135        pass
5136
5137    def __gt__(self, *args, **kwargs): # real signature unknown
5138        """ Return self>value. """
5139        pass
5140
5141    def __hash__(self, *args, **kwargs): # real signature unknown
5142        """ Return hash(self). """
5143        pass
5144
5145    def __init__(self, value='', encoding=None, errors='strict'): # known special case of str.__init__
5146        """
5147        str(object='') -> str
5148        str(bytes_or_buffer[, encoding[, errors]]) -> str
5149        
5150        Create a new string object from the given object. If encoding or
5151        errors is specified, then the object must expose a data buffer
5152        that will be decoded using the given encoding and error handler.
5153        Otherwise, returns the result of object.__str__() (if defined)
5154        or repr(object).
5155        encoding defaults to sys.getdefaultencoding().
5156        errors defaults to 'strict'.
5157        # (copied from class doc)
5158        """
5159        pass
5160
5161    def __iter__(self, *args, **kwargs): # real signature unknown
5162        """ Implement iter(self). """
5163        pass
5164
5165    def __len__(self, *args, **kwargs): # real signature unknown
5166        """ Return len(self). """
5167        pass
5168
5169    def __le__(self, *args, **kwargs): # real signature unknown
5170        """ Return self<=value. """
5171        pass
5172
5173    def __lt__(self, *args, **kwargs): # real signature unknown
5174        """ Return self<value. """
5175        pass
5176
5177    def __mod__(self, *args, **kwargs): # real signature unknown
5178        """ Return self%value. """
5179        pass
5180
5181    def __mul__(self, *args, **kwargs): # real signature unknown
5182        """ Return self*value.n """
5183        pass
5184
5185    @staticmethod # known case of __new__
5186    def __new__(*args, **kwargs): # real signature unknown
5187        """ Create and return a new object.  See help(type) for accurate signature. """
5188        pass
5189
5190    def __ne__(self, *args, **kwargs): # real signature unknown
5191        """ Return self!=value. """
5192        pass
5193
5194    def __repr__(self, *args, **kwargs): # real signature unknown
5195        """ Return repr(self). """
5196        pass
5197
5198    def __rmod__(self, *args, **kwargs): # real signature unknown
5199        """ Return value%self. """
5200        pass
5201
5202    def __rmul__(self, *args, **kwargs): # real signature unknown
5203        """ Return self*value. """
5204        pass
5205
5206    def __sizeof__(self): # real signature unknown; restored from __doc__
5207        """ S.__sizeof__() -> size of S in memory, in bytes """
5208        pass
5209
5210    def __str__(self, *args, **kwargs): # real signature unknown
5211        """ Return str(self). """
5212        pass
5213
5214
5215class super(object):
5216    """
5217    super() -> same as super(__class__, <first argument>)
5218    super(type) -> unbound super object
5219    super(type, obj) -> bound super object; requires isinstance(obj, type)
5220    super(type, type2) -> bound super object; requires issubclass(type2, type)
5221    Typical use to call a cooperative superclass method:
5222    class C(B):
5223        def meth(self, arg):
5224            super().meth(arg)
5225    This works for class methods too:
5226    class C(B):
5227        @classmethod
5228        def cmeth(cls, arg):
5229            super().cmeth(arg)
5230    """
5231    def __getattribute__(self, *args, **kwargs): # real signature unknown
5232        """ Return getattr(self, name). """
5233        pass
5234
5235    def __get__(self, *args, **kwargs): # real signature unknown
5236        """ Return an attribute of instance, which is of type owner. """
5237        pass
5238
5239    def __init__(self, type1=None, type2=None): # known special case of super.__init__
5240        """
5241        super() -> same as super(__class__, <first argument>)
5242        super(type) -> unbound super object
5243        super(type, obj) -> bound super object; requires isinstance(obj, type)
5244        super(type, type2) -> bound super object; requires issubclass(type2, type)
5245        Typical use to call a cooperative superclass method:
5246        class C(B):
5247            def meth(self, arg):
5248                super().meth(arg)
5249        This works for class methods too:
5250        class C(B):
5251            @classmethod
5252            def cmeth(cls, arg):
5253                super().cmeth(arg)
5254        
5255        # (copied from class doc)
5256        """
5257        pass
5258
5259    @staticmethod # known case of __new__
5260    def __new__(*args, **kwargs): # real signature unknown
5261        """ Create and return a new object.  See help(type) for accurate signature. """
5262        pass
5263
5264    def __repr__(self, *args, **kwargs): # real signature unknown
5265        """ Return repr(self). """
5266        pass
5267
5268    __self_class__ = property(lambda self: type(object))
5269    """the type of the instance invoking super(); may be None
5270
5271    :type: type
5272    """
5273
5274    __self__ = property(lambda self: type(object))
5275    """the instance invoking super(); may be None
5276
5277    :type: type
5278    """
5279
5280    __thisclass__ = property(lambda self: type(object))
5281    """the class invoking super()
5282
5283    :type: type
5284    """
5285
5286
5287
5288class SyntaxWarning(Warning):
5289    """ Base class for warnings about dubious syntax. """
5290    def __init__(self, *args, **kwargs): # real signature unknown
5291        pass
5292
5293    @staticmethod # known case of __new__
5294    def __new__(*args, **kwargs): # real signature unknown
5295        """ Create and return a new object.  See help(type) for accurate signature. """
5296        pass
5297
5298
5299class SystemError(Exception):
5300    """
5301    Internal error in the Python interpreter.
5302    
5303    Please report this to the Python maintainer, along with the traceback,
5304    the Python version, and the hardware/OS platform and version.
5305    """
5306    def __init__(self, *args, **kwargs): # real signature unknown
5307        pass
5308
5309    @staticmethod # known case of __new__
5310    def __new__(*args, **kwargs): # real signature unknown
5311        """ Create and return a new object.  See help(type) for accurate signature. """
5312        pass
5313
5314
5315class SystemExit(BaseException):
5316    """ Request to exit from the interpreter. """
5317    def __init__(self, *args, **kwargs): # real signature unknown
5318        pass
5319
5320    code = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5321    """exception code"""
5322
5323
5324
5325class TabError(IndentationError):
5326    """ Improper mixture of spaces and tabs. """
5327    def __init__(self, *args, **kwargs): # real signature unknown
5328        pass
5329
5330
5331class TimeoutError(OSError):
5332    """ Timeout expired. """
5333    def __init__(self, *args, **kwargs): # real signature unknown
5334        pass
5335
5336
5337class tuple(object):
5338    """
5339    tuple() -> empty tuple
5340    tuple(iterable) -> tuple initialized from iterable's items
5341    
5342    If the argument is a tuple, the return value is the same object.
5343    """
5344    def count(self, value): # real signature unknown; restored from __doc__
5345        """ T.count(value) -> integer -- return number of occurrences of value """
5346        return 0
5347
5348    def index(self, value, start=None, stop=None): # real signature unknown; restored from __doc__
5349        """
5350        T.index(value, [start, [stop]]) -> integer -- return first index of value.
5351        Raises ValueError if the value is not present.
5352        """
5353        return 0
5354
5355    def __add__(self, *args, **kwargs): # real signature unknown
5356        """ Return self+value. """
5357        pass
5358
5359    def __contains__(self, *args, **kwargs): # real signature unknown
5360        """ Return key in self. """
5361        pass
5362
5363    def __eq__(self, *args, **kwargs): # real signature unknown
5364        """ Return self==value. """
5365        pass
5366
5367    def __getattribute__(self, *args, **kwargs): # real signature unknown
5368        """ Return getattr(self, name). """
5369        pass
5370
5371    def __getitem__(self, *args, **kwargs): # real signature unknown
5372        """ Return self[key]. """
5373        pass
5374
5375    def __getnewargs__(self, *args, **kwargs): # real signature unknown
5376        pass
5377
5378    def __ge__(self, *args, **kwargs): # real signature unknown
5379        """ Return self>=value. """
5380        pass
5381
5382    def __gt__(self, *args, **kwargs): # real signature unknown
5383        """ Return self>value. """
5384        pass
5385
5386    def __hash__(self, *args, **kwargs): # real signature unknown
5387        """ Return hash(self). """
5388        pass
5389
5390    def __init__(self, seq=()): # known special case of tuple.__init__
5391        """
5392        tuple() -> empty tuple
5393        tuple(iterable) -> tuple initialized from iterable's items
5394        
5395        If the argument is a tuple, the return value is the same object.
5396        # (copied from class doc)
5397        """
5398        pass
5399
5400    def __iter__(self, *args, **kwargs): # real signature unknown
5401        """ Implement iter(self). """
5402        pass
5403
5404    def __len__(self, *args, **kwargs): # real signature unknown
5405        """ Return len(self). """
5406        pass
5407
5408    def __le__(self, *args, **kwargs): # real signature unknown
5409        """ Return self<=value. """
5410        pass
5411
5412    def __lt__(self, *args, **kwargs): # real signature unknown
5413        """ Return self<value. """
5414        pass
5415
5416    def __mul__(self, *args, **kwargs): # real signature unknown
5417        """ Return self*value.n """
5418        pass
5419
5420    @staticmethod # known case of __new__
5421    def __new__(*args, **kwargs): # real signature unknown
5422        """ Create and return a new object.  See help(type) for accurate signature. """
5423        pass
5424
5425    def __ne__(self, *args, **kwargs): # real signature unknown
5426        """ Return self!=value. """
5427        pass
5428
5429    def __repr__(self, *args, **kwargs): # real signature unknown
5430        """ Return repr(self). """
5431        pass
5432
5433    def __rmul__(self, *args, **kwargs): # real signature unknown
5434        """ Return self*value. """
5435        pass
5436
5437
5438class type(object):
5439    """
5440    type(object_or_name, bases, dict)
5441    type(object) -> the object's type
5442    type(name, bases, dict) -> a new type
5443    """
5444    def mro(self): # real signature unknown; restored from __doc__
5445        """
5446        mro() -> list
5447        return a type's method resolution order
5448        """
5449        return []
5450
5451    def __call__(self, *args, **kwargs): # real signature unknown
5452        """ Call self as a function. """
5453        pass
5454
5455    def __delattr__(self, *args, **kwargs): # real signature unknown
5456        """ Implement delattr(self, name). """
5457        pass
5458
5459    def __dir__(self): # real signature unknown; restored from __doc__
5460        """
5461        __dir__() -> list
5462        specialized __dir__ implementation for types
5463        """
5464        return []
5465
5466    def __getattribute__(self, *args, **kwargs): # real signature unknown
5467        """ Return getattr(self, name). """
5468        pass
5469
5470    def __init__(cls, what, bases=None, dict=None): # known special case of type.__init__
5471        """
5472        type(object_or_name, bases, dict)
5473        type(object) -> the object's type
5474        type(name, bases, dict) -> a new type
5475        # (copied from class doc)
5476        """
5477        pass
5478
5479    def __instancecheck__(self): # real signature unknown; restored from __doc__
5480        """
5481        __instancecheck__() -> bool
5482        check if an object is an instance
5483        """
5484        return False
5485
5486    @staticmethod # known case of __new__
5487    def __new__(*args, **kwargs): # real signature unknown
5488        """ Create and return a new object.  See help(type) for accurate signature. """
5489        pass
5490
5491    def __prepare__(self): # real signature unknown; restored from __doc__
5492        """
5493        __prepare__() -> dict
5494        used to create the namespace for the class statement
5495        """
5496        return {}
5497
5498    def __repr__(self, *args, **kwargs): # real signature unknown
5499        """ Return repr(self). """
5500        pass
5501
5502    def __setattr__(self, *args, **kwargs): # real signature unknown
5503        """ Implement setattr(self, name, value). """
5504        pass
5505
5506    def __sizeof__(self): # real signature unknown; restored from __doc__
5507        """
5508        __sizeof__() -> int
5509        return memory consumption of the type object
5510        """
5511        return 0
5512
5513    def __subclasscheck__(self): # real signature unknown; restored from __doc__
5514        """
5515        __subclasscheck__() -> bool
5516        check if a class is a subclass
5517        """
5518        return False
5519
5520    def __subclasses__(self): # real signature unknown; restored from __doc__
5521        """ __subclasses__() -> list of immediate subclasses """
5522        return []
5523
5524    __abstractmethods__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5525
5526
5527    __bases__ = (
5528        object,
5529    )
5530    __base__ = object
5531    __basicsize__ = 864
5532    __dictoffset__ = 264
5533    __dict__ = None # (!) real value is ''
5534    __flags__ = 2148291584
5535    __itemsize__ = 40
5536    __mro__ = (
5537        None, # (!) forward: type, real value is ''
5538        object,
5539    )
5540    __name__ = 'type'
5541    __qualname__ = 'type'
5542    __text_signature__ = None
5543    __weakrefoffset__ = 368
5544
5545
5546class TypeError(Exception):
5547    """ Inappropriate argument type. """
5548    def __init__(self, *args, **kwargs): # real signature unknown
5549        pass
5550
5551    @staticmethod # known case of __new__
5552    def __new__(*args, **kwargs): # real signature unknown
5553        """ Create and return a new object.  See help(type) for accurate signature. """
5554        pass
5555
5556
5557class UnboundLocalError(NameError):
5558    """ Local name referenced but not bound to a value. """
5559    def __init__(self, *args, **kwargs): # real signature unknown
5560        pass
5561
5562    @staticmethod # known case of __new__
5563    def __new__(*args, **kwargs): # real signature unknown
5564        """ Create and return a new object.  See help(type) for accurate signature. """
5565        pass
5566
5567
5568class ValueError(Exception):
5569    """ Inappropriate argument value (of correct type). """
5570    def __init__(self, *args, **kwargs): # real signature unknown
5571        pass
5572
5573    @staticmethod # known case of __new__
5574    def __new__(*args, **kwargs): # real signature unknown
5575        """ Create and return a new object.  See help(type) for accurate signature. """
5576        pass
5577
5578
5579class UnicodeError(ValueError):
5580    """ Unicode related error. """
5581    def __init__(self, *args, **kwargs): # real signature unknown
5582        pass
5583
5584    @staticmethod # known case of __new__
5585    def __new__(*args, **kwargs): # real signature unknown
5586        """ Create and return a new object.  See help(type) for accurate signature. """
5587        pass
5588
5589
5590class UnicodeDecodeError(UnicodeError):
5591    """ Unicode decoding error. """
5592    def __init__(self, *args, **kwargs): # real signature unknown
5593        pass
5594
5595    @staticmethod # known case of __new__
5596    def __new__(*args, **kwargs): # real signature unknown
5597        """ Create and return a new object.  See help(type) for accurate signature. """
5598        pass
5599
5600    def __str__(self, *args, **kwargs): # real signature unknown
5601        """ Return str(self). """
5602        pass
5603
5604    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5605    """exception encoding"""
5606
5607    end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5608    """exception end"""
5609
5610    object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5611    """exception object"""
5612
5613    reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5614    """exception reason"""
5615
5616    start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5617    """exception start"""
5618
5619
5620
5621class UnicodeEncodeError(UnicodeError):
5622    """ Unicode encoding error. """
5623    def __init__(self, *args, **kwargs): # real signature unknown
5624        pass
5625
5626    @staticmethod # known case of __new__
5627    def __new__(*args, **kwargs): # real signature unknown
5628        """ Create and return a new object.  See help(type) for accurate signature. """
5629        pass
5630
5631    def __str__(self, *args, **kwargs): # real signature unknown
5632        """ Return str(self). """
5633        pass
5634
5635    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5636    """exception encoding"""
5637
5638    end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5639    """exception end"""
5640
5641    object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5642    """exception object"""
5643
5644    reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5645    """exception reason"""
5646
5647    start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5648    """exception start"""
5649
5650
5651
5652class UnicodeTranslateError(UnicodeError):
5653    """ Unicode translation error. """
5654    def __init__(self, *args, **kwargs): # real signature unknown
5655        pass
5656
5657    @staticmethod # known case of __new__
5658    def __new__(*args, **kwargs): # real signature unknown
5659        """ Create and return a new object.  See help(type) for accurate signature. """
5660        pass
5661
5662    def __str__(self, *args, **kwargs): # real signature unknown
5663        """ Return str(self). """
5664        pass
5665
5666    encoding = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5667    """exception encoding"""
5668
5669    end = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5670    """exception end"""
5671
5672    object = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5673    """exception object"""
5674
5675    reason = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5676    """exception reason"""
5677
5678    start = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5679    """exception start"""
5680
5681
5682
5683class UnicodeWarning(Warning):
5684    """
5685    Base class for warnings about Unicode related problems, mostly
5686    related to conversion problems.
5687    """
5688    def __init__(self, *args, **kwargs): # real signature unknown
5689        pass
5690
5691    @staticmethod # known case of __new__
5692    def __new__(*args, **kwargs): # real signature unknown
5693        """ Create and return a new object.  See help(type) for accurate signature. """
5694        pass
5695
5696
5697class UserWarning(Warning):
5698    """ Base class for warnings generated by user code. """
5699    def __init__(self, *args, **kwargs): # real signature unknown
5700        pass
5701
5702    @staticmethod # known case of __new__
5703    def __new__(*args, **kwargs): # real signature unknown
5704        """ Create and return a new object.  See help(type) for accurate signature. """
5705        pass
5706
5707
5708class ZeroDivisionError(ArithmeticError):
5709    """ Second argument to a division or modulo operation was zero. """
5710    def __init__(self, *args, **kwargs): # real signature unknown
5711        pass
5712
5713    @staticmethod # known case of __new__
5714    def __new__(*args, **kwargs): # real signature unknown
5715        """ Create and return a new object.  See help(type) for accurate signature. """
5716        pass
5717
5718
5719class zip(object):
5720    """
5721    zip(iter1 [,iter2 [...]]) --> zip object
5722    
5723    Return a zip object whose .__next__() method returns a tuple where
5724    the i-th element comes from the i-th iterable argument.  The .__next__()
5725    method continues until the shortest iterable in the argument sequence
5726    is exhausted and then it raises StopIteration.
5727    """
5728    def __getattribute__(self, *args, **kwargs): # real signature unknown
5729        """ Return getattr(self, name). """
5730        pass
5731
5732    def __init__(self, iter1, iter2=None, *some): # real signature unknown; restored from __doc__
5733        pass
5734
5735    def __iter__(self, *args, **kwargs): # real signature unknown
5736        """ Implement iter(self). """
5737        pass
5738
5739    @staticmethod # known case of __new__
5740    def __new__(*args, **kwargs): # real signature unknown
5741        """ Create and return a new object.  See help(type) for accurate signature. """
5742        pass
5743
5744    def __next__(self, *args, **kwargs): # real signature unknown
5745        """ Implement next(self). """
5746        pass
5747
5748    def __reduce__(self, *args, **kwargs): # real signature unknown
5749        """ Return state information for pickling. """
5750        pass
5751
5752
5753class __loader__(object):
5754    """
5755    Meta path import for built-in modules.
5756    
5757        All methods are either class or static methods to avoid the need to
5758        instantiate the class.
5759    """
5760    def create_module(self, *args, **kwargs): # real signature unknown
5761        """ Create a built-in module """
5762        pass
5763
5764    def exec_module(self, *args, **kwargs): # real signature unknown
5765        """ Exec a built-in module """
5766        pass
5767
5768    def find_module(self, *args, **kwargs): # real signature unknown
5769        """
5770        Find the built-in module.
5771        
5772                If 'path' is ever specified then the search is considered a failure.
5773        
5774                This method is deprecated.  Use find_spec() instead.
5775        """
5776        pass
5777
5778    def find_spec(self, *args, **kwargs): # real signature unknown
5779        pass
5780
5781    def get_code(self, *args, **kwargs): # real signature unknown
5782        """ Return None as built-in modules do not have code objects. """
5783        pass
5784
5785    def get_source(self, *args, **kwargs): # real signature unknown
5786        """ Return None as built-in modules do not have source code. """
5787        pass
5788
5789    def is_package(self, *args, **kwargs): # real signature unknown
5790        """ Return False as built-in modules are never packages. """
5791        pass
5792
5793    def load_module(self, *args, **kwargs): # real signature unknown
5794        """
5795        Load the specified module into sys.modules and return it.
5796        
5797            This method is deprecated.  Use loader.exec_module instead.
5798        """
5799        pass
5800
5801    def module_repr(module): # reliably restored by inspect
5802        """
5803        Return repr for the module.
5804        
5805                The method is deprecated.  The import machinery does the job itself.
5806        """
5807        pass
5808
5809    def __init__(self, *args, **kwargs): # real signature unknown
5810        pass
5811
5812    __weakref__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
5813    """list of weak references to the object (if defined)"""
5814
5815
5816    __dict__ = None # (!) real value is ''
5817
5818
5819# variables with complex values
5820
5821Ellipsis = None # (!) real value is ''
5822
5823NotImplemented = None # (!) real value is ''
5824
5825__spec__ = None # (!) real value is ''