docs.inc.rs

[
    ("_abc", Some("Module contains faster C implementation of abc.ABCMeta")),
    ("_abc._abc_init", Some("Internal ABC helper for class set-up. Should be never used outside abc module.")),
    ("_abc._abc_instancecheck", Some("Internal ABC helper for instance checks. Should be never used outside abc module.")),
    ("_abc._abc_register", Some("Internal ABC helper for subclasss registration. Should be never used outside abc module.")),
    ("_abc._abc_subclasscheck", Some("Internal ABC helper for subclasss checks. Should be never used outside abc module.")),
    ("_abc._get_dump", Some("Internal ABC helper for cache and registry debugging.\n\nReturn shallow copies of registry, of both caches, and\nnegative cache version. Don't call this function directly,\ninstead use ABC._dump_registry() for a nice repr.")),
    ("_abc._reset_caches", Some("Internal ABC helper to reset both caches of a given class.\n\nShould be only used by refleak.py")),
    ("_abc._reset_registry", Some("Internal ABC helper to reset registry of a given class.\n\nShould be only used by refleak.py")),
    ("_abc.get_cache_token", Some("Returns the current ABC cache token.\n\nThe token is an opaque object (supporting equality testing) identifying the\ncurrent version of the ABC cache for virtual subclasses. The token changes\nwith every call to register() on any ABC.")),
    ("_codecs.ascii_decode", None),
    ("_codecs.ascii_encode", None),
    ("_codecs.charmap_build", None),
    ("_codecs.charmap_decode", None),
    ("_codecs.charmap_encode", None),
    ("_codecs.decode", Some("Decodes obj using the codec registered for encoding.\n\nDefault encoding is 'utf-8'.  errors may be given to set a\ndifferent error handling scheme.  Default is 'strict' meaning that encoding\nerrors raise a ValueError.  Other possible values are 'ignore', 'replace'\nand 'backslashreplace' as well as any other name registered with\ncodecs.register_error that can handle ValueErrors.")),
    ("_codecs.encode", Some("Encodes obj using the codec registered for encoding.\n\nThe default encoding is 'utf-8'.  errors may be given to set a\ndifferent error handling scheme.  Default is 'strict' meaning that encoding\nerrors raise a ValueError.  Other possible values are 'ignore', 'replace'\nand 'backslashreplace' as well as any other name registered with\ncodecs.register_error that can handle ValueErrors.")),
    ("_codecs.escape_decode", None),
    ("_codecs.escape_encode", None),
    ("_codecs.latin_1_decode", None),
    ("_codecs.latin_1_encode", None),
    ("_codecs.lookup", Some("Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.")),
    ("_codecs.lookup_error", Some("lookup_error(errors) -> handler\n\nReturn the error handler for the specified error handling name or raise a\nLookupError, if no handler exists under this name.")),
    ("_codecs.raw_unicode_escape_decode", None),
    ("_codecs.raw_unicode_escape_encode", None),
    ("_codecs.readbuffer_encode", None),
    ("_codecs.register", Some("Register a codec search function.\n\nSearch functions are expected to take one argument, the encoding name in\nall lower case letters, and either return None, or a tuple of functions\n(encoder, decoder, stream_reader, stream_writer) (or a CodecInfo object).")),
    ("_codecs.register_error", Some("Register the specified error handler under the name errors.\n\nhandler must be a callable object, that will be called with an exception\ninstance containing information about the location of the encoding/decoding\nerror and must return a (replacement, new position) tuple.")),
    ("_codecs.unicode_escape_decode", None),
    ("_codecs.unicode_escape_encode", None),
    ("_codecs.unregister", Some("Unregister a codec search function and clear the registry's cache.\n\nIf the search function is not registered, do nothing.")),
    ("_codecs.utf_16_be_decode", None),
    ("_codecs.utf_16_be_encode", None),
    ("_codecs.utf_16_decode", None),
    ("_codecs.utf_16_encode", None),
    ("_codecs.utf_16_ex_decode", None),
    ("_codecs.utf_16_le_decode", None),
    ("_codecs.utf_16_le_encode", None),
    ("_codecs.utf_32_be_decode", None),
    ("_codecs.utf_32_be_encode", None),
    ("_codecs.utf_32_decode", None),
    ("_codecs.utf_32_encode", None),
    ("_codecs.utf_32_ex_decode", None),
    ("_codecs.utf_32_le_decode", None),
    ("_codecs.utf_32_le_encode", None),
    ("_codecs.utf_7_decode", None),
    ("_codecs.utf_7_encode", None),
    ("_codecs.utf_8_decode", None),
    ("_codecs.utf_8_encode", None),
    ("_collections", Some("High performance data structures.\n- deque:        ordered collection accessible from endpoints only\n- defaultdict:  dict subclass with a default value factory\n")),
    ("_collections._count_elements", Some("Count elements in the iterable, updating the mapping")),
    ("_collections._deque_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_collections._deque_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_collections._deque_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_collections._deque_reverse_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_collections._deque_reverse_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_collections._deque_reverse_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_collections._tuplegetter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_collections._tuplegetter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_collections._tuplegetter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_functools", Some("Tools that operate on functions.")),
    ("_functools.cmp_to_key", Some("Convert a cmp= function into a key= function.")),
    ("_functools.reduce", Some("reduce(function, iterable[, initial]) -> value\n\nApply a function of two arguments cumulatively to the items of a sequence\nor iterable, from left to right, so as to reduce the iterable to a single\nvalue.  For example, reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) calculates\n((((1+2)+3)+4)+5).  If initial is present, it is placed before the items\nof the iterable in the calculation, and serves as a default when the\niterable is empty.")),
    ("_imp", Some("(Extremely) low-level import machinery bits as used by importlib and imp.")),
    ("_imp._fix_co_filename", Some("Changes code.co_filename to specify the passed-in file path.\n\n  code\n    Code object to change.\n  path\n    File path to use.")),
    ("_imp._frozen_module_names", Some("Returns the list of available frozen modules.")),
    ("_imp._override_frozen_modules_for_tests", Some("(internal-only) Override PyConfig.use_frozen_modules.\n\n(-1: \"off\", 1: \"on\", 0: no override)\nSee frozen_modules() in Lib/test/support/import_helper.py.")),
    ("_imp.acquire_lock", Some("Acquires the interpreter's import lock for the current thread.\n\nThis lock should be used by import hooks to ensure thread-safety when importing\nmodules. On platforms without threads, this function does nothing.")),
    ("_imp.create_builtin", Some("Create an extension module.")),
    ("_imp.create_dynamic", Some("Create an extension module.")),
    ("_imp.exec_builtin", Some("Initialize a built-in module.")),
    ("_imp.exec_dynamic", Some("Initialize an extension module.")),
    ("_imp.extension_suffixes", Some("Returns the list of file suffixes used to identify extension modules.")),
    ("_imp.find_frozen", Some("Return info about the corresponding frozen module (if there is one) or None.\n\nThe returned info (a 2-tuple):\n\n * data         the raw marshalled bytes\n * is_package   whether or not it is a package\n * origname     the originally frozen module's name, or None if not\n                a stdlib module (this will usually be the same as\n                the module's current name)")),
    ("_imp.get_frozen_object", Some("Create a code object for a frozen module.")),
    ("_imp.init_frozen", Some("Initializes a frozen module.")),
    ("_imp.is_builtin", Some("Returns True if the module name corresponds to a built-in module.")),
    ("_imp.is_frozen", Some("Returns True if the module name corresponds to a frozen module.")),
    ("_imp.is_frozen_package", Some("Returns True if the module name is of a frozen package.")),
    ("_imp.lock_held", Some("Return True if the import lock is currently held, else False.\n\nOn platforms without threads, return False.")),
    ("_imp.release_lock", Some("Release the interpreter's import lock.\n\nOn platforms without threads, this function does nothing.")),
    ("_imp.source_hash", None),
    ("_io", Some("The io module provides the Python interfaces to stream handling. The\nbuiltin open function is defined in this module.\n\nAt the top of the I/O hierarchy is the abstract base class IOBase. It\ndefines the basic interface to a stream. Note, however, that there is no\nseparation between reading and writing to streams; implementations are\nallowed to raise an OSError if they do not support a given operation.\n\nExtending IOBase is RawIOBase which deals simply with the reading and\nwriting of raw bytes to a stream. FileIO subclasses RawIOBase to provide\nan interface to OS files.\n\nBufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\nsubclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\nstreams that are readable, writable, and both respectively.\nBufferedRandom provides a buffered interface to random access\nstreams. BytesIO is a simple stream of in-memory bytes.\n\nAnother IOBase subclass, TextIOBase, deals with the encoding and decoding\nof streams into text. TextIOWrapper, which extends it, is a buffered text\ninterface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\nis an in-memory stream for text.\n\nArgument names are not part of the specification, and only the arguments\nof open() are intended to be used as keyword arguments.\n\ndata:\n\nDEFAULT_BUFFER_SIZE\n\n   An int containing the default buffer size used by the module's buffered\n   I/O classes. open() uses the file's blksize (as obtained by os.stat) if\n   possible.\n")),
    ("_io.BufferedRWPair", Some("A buffered reader and writer object together.\n\nA buffered reader object and buffered writer object put together to\nform a sequential IO object that can read and write. This is typically\nused with a socket or two-way pipe.\n\nreader and writer are RawIOBase objects that are readable and\nwriteable respectively. If the buffer_size is omitted it defaults to\nDEFAULT_BUFFER_SIZE.")),
    ("_io.BufferedRWPair.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.BufferedRWPair.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.BufferedRWPair.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.BufferedRandom", Some("A buffered interface to random access streams.\n\nThe constructor creates a reader and writer for a seekable stream,\nraw, given in the first argument. If the buffer_size is omitted it\ndefaults to DEFAULT_BUFFER_SIZE.")),
    ("_io.BufferedRandom.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.BufferedRandom.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.BufferedRandom.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.BufferedReader", Some("Create a new buffered reader using the given readable raw IO object.")),
    ("_io.BufferedReader.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.BufferedReader.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.BufferedReader.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.BufferedWriter", Some("A buffer for a writeable sequential RawIO object.\n\nThe constructor creates a BufferedWriter for the given writeable raw\nstream. If the buffer_size is not given, it defaults to\nDEFAULT_BUFFER_SIZE.")),
    ("_io.BufferedWriter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.BufferedWriter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.BufferedWriter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.BytesIO", Some("Buffered I/O implementation using an in-memory bytes buffer.")),
    ("_io.BytesIO.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.BytesIO.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.BytesIO.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.FileIO", Some("Open a file.\n\nThe mode can be 'r' (default), 'w', 'x' or 'a' for reading,\nwriting, exclusive creation or appending.  The file will be created if it\ndoesn't exist when opened for writing or appending; it will be truncated\nwhen opened for writing.  A FileExistsError will be raised if it already\nexists when opened for creating. Opening a file for creating implies\nwriting so this mode behaves in a similar way to 'w'.Add a '+' to the mode\nto allow simultaneous reading and writing. A custom opener can be used by\npassing a callable as *opener*. The underlying file descriptor for the file\nobject is then obtained by calling opener with (*name*, *flags*).\n*opener* must return an open file descriptor (passing os.open as *opener*\nresults in functionality similar to passing None).")),
    ("_io.FileIO.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.FileIO.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.FileIO.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.IncrementalNewlineDecoder", Some("Codec used when reading a file in universal newlines mode.\n\nIt wraps another incremental decoder, translating \\r\\n and \\r into \\n.\nIt also records the types of newlines encountered.  When used with\ntranslate=False, it ensures that the newline sequence is returned in\none piece. When used with decoder=None, it expects unicode strings as\ndecode input and translates newlines without first invoking an external\ndecoder.")),
    ("_io.IncrementalNewlineDecoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.IncrementalNewlineDecoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.IncrementalNewlineDecoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.StringIO", Some("Text I/O implementation using an in-memory buffer.\n\nThe initial_value argument sets the value of object.  The newline\nargument is like the one of TextIOWrapper's constructor.")),
    ("_io.StringIO.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.StringIO.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.StringIO.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io.TextIOWrapper", Some("Character and line based layer over a BufferedIOBase object, buffer.\n\nencoding gives the name of the encoding that the stream will be\ndecoded or encoded with. It defaults to locale.getencoding().\n\nerrors determines the strictness of encoding and decoding (see\nhelp(codecs.Codec) or the documentation for codecs.register) and\ndefaults to \"strict\".\n\nnewline controls how line endings are handled. It can be None, '',\n'\\n', '\\r', and '\\r\\n'.  It works as follows:\n\n* On input, if newline is None, universal newlines mode is\n  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n  these are translated into '\\n' before being returned to the\n  caller. If it is '', universal newline mode is enabled, but line\n  endings are returned to the caller untranslated. If it has any of\n  the other legal values, input lines are only terminated by the given\n  string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n  translated to the system default line separator, os.linesep. If\n  newline is '' or '\\n', no translation takes place. If newline is any\n  of the other legal values, any '\\n' characters written are translated\n  to the given string.\n\nIf line_buffering is True, a call to flush is implied when a call to\nwrite contains a newline character.")),
    ("_io.TextIOWrapper.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io.TextIOWrapper.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io.TextIOWrapper.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io._BufferedIOBase", Some("Base class for buffered IO objects.\n\nThe main difference with RawIOBase is that the read() method\nsupports omitting the size argument, and does not have a default\nimplementation that defers to readinto().\n\nIn addition, read(), readinto() and write() may raise\nBlockingIOError if the underlying raw stream is in non-blocking\nmode and not ready; unlike their raw counterparts, they will never\nreturn None.\n\nA typical implementation should not inherit from a RawIOBase\nimplementation, but wrap one.\n")),
    ("_io._BufferedIOBase.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io._BufferedIOBase.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io._BufferedIOBase.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io._IOBase", Some("The abstract base class for all I/O classes.\n\nThis class provides dummy implementations for many methods that\nderived classes can override selectively; the default implementations\nrepresent a file that cannot be read, written or seeked.\n\nEven though IOBase does not declare read, readinto, or write because\ntheir signatures will vary, implementations and clients should\nconsider those methods part of the interface. Also, implementations\nmay raise UnsupportedOperation when operations they do not support are\ncalled.\n\nThe basic type used for binary data read from or written to a file is\nbytes. Other bytes-like objects are accepted as method arguments too.\nIn some cases (such as readinto), a writable object is required. Text\nI/O classes work with str data.\n\nNote that calling any method (except additional calls to close(),\nwhich are ignored) on a closed stream should raise a ValueError.\n\nIOBase (and its subclasses) support the iterator protocol, meaning\nthat an IOBase object can be iterated over yielding the lines in a\nstream.\n\nIOBase also supports the :keyword:`with` statement. In this example,\nfp is closed after the suite of the with statement is complete:\n\nwith open('spam.txt', 'r') as fp:\n    fp.write('Spam and eggs!')\n")),
    ("_io._IOBase.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io._IOBase.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io._IOBase.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io._RawIOBase", Some("Base class for raw binary I/O.")),
    ("_io._RawIOBase.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io._RawIOBase.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io._RawIOBase.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_io._TextIOBase", Some("Base class for text I/O.\n\nThis class provides a character and line based interface to stream\nI/O. There is no readinto method because Python's character strings\nare immutable.\n")),
    ("_io._TextIOBase.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_io._TextIOBase.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_io._TextIOBase.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_locale", Some("Support for POSIX locales.")),
    ("_locale.bind_textdomain_codeset", Some("Bind the C library's domain to codeset.")),
    ("_locale.bindtextdomain", Some("Bind the C library's domain to dir.")),
    ("_locale.dcgettext", Some("Return translation of msg in domain and category.")),
    ("_locale.dgettext", Some("dgettext(domain, msg) -> string\n\nReturn translation of msg in domain.")),
    ("_locale.getencoding", Some("Get the current locale encoding.")),
    ("_locale.gettext", Some("gettext(msg) -> string\n\nReturn translation of msg.")),
    ("_locale.localeconv", Some("Returns numeric and monetary locale-specific parameters.")),
    ("_locale.nl_langinfo", Some("Return the value for the locale information associated with key.")),
    ("_locale.setlocale", Some("Activates/queries locale processing.")),
    ("_locale.strcoll", Some("Compares two strings according to the locale.")),
    ("_locale.strxfrm", Some("Return a string that can be used as a key for locale-aware comparisons.")),
    ("_locale.textdomain", Some("Set the C library's textdmain to domain, returning the new domain.")),
    ("_operator", Some("Operator interface.\n\nThis module exports a set of functions implemented in C corresponding\nto the intrinsic operators of Python.  For example, operator.add(x, y)\nis equivalent to the expression x+y.  The function names are those\nused for special methods; variants without leading and trailing\n'__' are also provided for convenience.")),
    ("_operator._compare_digest", Some("Return 'a == b'.\n\nThis function uses an approach designed to prevent\ntiming analysis, making it appropriate for cryptography.\n\na and b must both be of the same type: either str (ASCII only),\nor any bytes-like object.\n\nNote: If a and b are of different lengths, or if an error occurs,\na timing attack could theoretically reveal information about the\ntypes and lengths of a and b--but not their values.")),
    ("_operator.abs", Some("Same as abs(a).")),
    ("_operator.add", Some("Same as a + b.")),
    ("_operator.and_", Some("Same as a & b.")),
    ("_operator.call", Some("Same as obj(*args, **kwargs).")),
    ("_operator.concat", Some("Same as a + b, for a and b sequences.")),
    ("_operator.contains", Some("Same as b in a (note reversed operands).")),
    ("_operator.countOf", Some("Return the number of items in a which are, or which equal, b.")),
    ("_operator.delitem", Some("Same as del a[b].")),
    ("_operator.eq", Some("Same as a == b.")),
    ("_operator.floordiv", Some("Same as a // b.")),
    ("_operator.ge", Some("Same as a >= b.")),
    ("_operator.getitem", Some("Same as a[b].")),
    ("_operator.gt", Some("Same as a > b.")),
    ("_operator.iadd", Some("Same as a += b.")),
    ("_operator.iand", Some("Same as a &= b.")),
    ("_operator.iconcat", Some("Same as a += b, for a and b sequences.")),
    ("_operator.ifloordiv", Some("Same as a //= b.")),
    ("_operator.ilshift", Some("Same as a <<= b.")),
    ("_operator.imatmul", Some("Same as a @= b.")),
    ("_operator.imod", Some("Same as a %= b.")),
    ("_operator.imul", Some("Same as a *= b.")),
    ("_operator.index", Some("Same as a.__index__()")),
    ("_operator.indexOf", Some("Return the first index of b in a.")),
    ("_operator.inv", Some("Same as ~a.")),
    ("_operator.invert", Some("Same as ~a.")),
    ("_operator.ior", Some("Same as a |= b.")),
    ("_operator.ipow", Some("Same as a **= b.")),
    ("_operator.irshift", Some("Same as a >>= b.")),
    ("_operator.is_", Some("Same as a is b.")),
    ("_operator.is_not", Some("Same as a is not b.")),
    ("_operator.isub", Some("Same as a -= b.")),
    ("_operator.itruediv", Some("Same as a /= b.")),
    ("_operator.ixor", Some("Same as a ^= b.")),
    ("_operator.le", Some("Same as a <= b.")),
    ("_operator.length_hint", Some("Return an estimate of the number of items in obj.\n\nThis is useful for presizing containers when building from an iterable.\n\nIf the object supports len(), the result will be exact.\nOtherwise, it may over- or under-estimate by an arbitrary amount.\nThe result will be an integer >= 0.")),
    ("_operator.lshift", Some("Same as a << b.")),
    ("_operator.lt", Some("Same as a < b.")),
    ("_operator.matmul", Some("Same as a @ b.")),
    ("_operator.mod", Some("Same as a % b.")),
    ("_operator.mul", Some("Same as a * b.")),
    ("_operator.ne", Some("Same as a != b.")),
    ("_operator.neg", Some("Same as -a.")),
    ("_operator.not_", Some("Same as not a.")),
    ("_operator.or_", Some("Same as a | b.")),
    ("_operator.pos", Some("Same as +a.")),
    ("_operator.pow", Some("Same as a ** b.")),
    ("_operator.rshift", Some("Same as a >> b.")),
    ("_operator.setitem", Some("Same as a[b] = c.")),
    ("_operator.sub", Some("Same as a - b.")),
    ("_operator.truediv", Some("Same as a / b.")),
    ("_operator.truth", Some("Return True if a is true, False otherwise.")),
    ("_operator.xor", Some("Same as a ^ b.")),
    ("_signal", Some("This module provides mechanisms to use signal handlers in Python.\n\nFunctions:\n\nalarm() -- cause SIGALRM after a specified time [Unix only]\nsetitimer() -- cause a signal (described below) after a specified\n               float time and the timer may restart then [Unix only]\ngetitimer() -- get current value of timer [Unix only]\nsignal() -- set the action for a given signal\ngetsignal() -- get the signal action for a given signal\npause() -- wait until a signal arrives [Unix only]\ndefault_int_handler() -- default SIGINT handler\n\nsignal constants:\nSIG_DFL -- used to refer to the system default handler\nSIG_IGN -- used to ignore the signal\nNSIG -- number of defined signals\nSIGINT, SIGTERM, etc. -- signal numbers\n\nitimer constants:\nITIMER_REAL -- decrements in real time, and delivers SIGALRM upon\n               expiration\nITIMER_VIRTUAL -- decrements only when the process is executing,\n               and delivers SIGVTALRM upon expiration\nITIMER_PROF -- decrements both when the process is executing and\n               when the system is executing on behalf of the process.\n               Coupled with ITIMER_VIRTUAL, this timer is usually\n               used to profile the time spent by the application\n               in user and kernel space. SIGPROF is delivered upon\n               expiration.\n\n\n*** IMPORTANT NOTICE ***\nA signal handler function is called with two arguments:\nthe first is the signal number, the second is the interrupted stack frame.")),
    ("_signal.alarm", Some("Arrange for SIGALRM to arrive after the given number of seconds.")),
    ("_signal.default_int_handler", Some("The default handler for SIGINT installed by Python.\n\nIt raises KeyboardInterrupt.")),
    ("_signal.getitimer", Some("Returns current value of given itimer.")),
    ("_signal.getsignal", Some("Return the current action for the given signal.\n\nThe return value can be:\n  SIG_IGN -- if the signal is being ignored\n  SIG_DFL -- if the default action for the signal is in effect\n  None    -- if an unknown handler is in effect\n  anything else -- the callable Python object used as a handler")),
    ("_signal.pause", Some("Wait until a signal arrives.")),
    ("_signal.pthread_kill", Some("Send a signal to a thread.")),
    ("_signal.pthread_sigmask", Some("Fetch and/or change the signal mask of the calling thread.")),
    ("_signal.raise_signal", Some("Send a signal to the executing process.")),
    ("_signal.set_wakeup_fd", Some("set_wakeup_fd(fd, *, warn_on_full_buffer=True) -> fd\n\nSets the fd to be written to (with the signal number) when a signal\ncomes in.  A library can use this to wakeup select or poll.\nThe previous fd or -1 is returned.\n\nThe fd must be non-blocking.")),
    ("_signal.setitimer", Some("Sets given itimer (one of ITIMER_REAL, ITIMER_VIRTUAL or ITIMER_PROF).\n\nThe timer will fire after value seconds and after that every interval seconds.\nThe itimer can be cleared by setting seconds to zero.\n\nReturns old values as a tuple: (delay, interval).")),
    ("_signal.siginterrupt", Some("Change system call restart behaviour.\n\nIf flag is False, system calls will be restarted when interrupted by\nsignal sig, else system calls will be interrupted.")),
    ("_signal.signal", Some("Set the action for the given signal.\n\nThe action can be SIG_DFL, SIG_IGN, or a callable Python object.\nThe previous action is returned.  See getsignal() for possible return values.\n\n*** IMPORTANT NOTICE ***\nA signal handler function is called with two arguments:\nthe first is the signal number, the second is the interrupted stack frame.")),
    ("_signal.sigpending", Some("Examine pending signals.\n\nReturns a set of signal numbers that are pending for delivery to\nthe calling thread.")),
    ("_signal.sigwait", Some("Wait for a signal.\n\nSuspend execution of the calling thread until the delivery of one of the\nsignals specified in the signal set sigset.  The function accepts the signal\nand returns the signal number.")),
    ("_signal.strsignal", Some("Return the system description of the given signal.\n\nReturns the description of signal *signalnum*, such as \"Interrupt\"\nfor :const:`SIGINT`. Returns :const:`None` if *signalnum* has no\ndescription. Raises :exc:`ValueError` if *signalnum* is invalid.")),
    ("_signal.valid_signals", Some("Return a set of valid signal numbers on this platform.\n\nThe signal numbers returned by this function can be safely passed to\nfunctions like `pthread_sigmask`.")),
    ("_sre.ascii_iscased", None),
    ("_sre.ascii_tolower", None),
    ("_sre.compile", None),
    ("_sre.getcodesize", None),
    ("_sre.unicode_iscased", None),
    ("_sre.unicode_tolower", None),
    ("_stat", Some("S_IFMT_: file type bits\nS_IFDIR: directory\nS_IFCHR: character device\nS_IFBLK: block device\nS_IFREG: regular file\nS_IFIFO: fifo (named pipe)\nS_IFLNK: symbolic link\nS_IFSOCK: socket file\nS_IFDOOR: door\nS_IFPORT: event port\nS_IFWHT: whiteout\n\nS_ISUID: set UID bit\nS_ISGID: set GID bit\nS_ENFMT: file locking enforcement\nS_ISVTX: sticky bit\nS_IREAD: Unix V7 synonym for S_IRUSR\nS_IWRITE: Unix V7 synonym for S_IWUSR\nS_IEXEC: Unix V7 synonym for S_IXUSR\nS_IRWXU: mask for owner permissions\nS_IRUSR: read by owner\nS_IWUSR: write by owner\nS_IXUSR: execute by owner\nS_IRWXG: mask for group permissions\nS_IRGRP: read by group\nS_IWGRP: write by group\nS_IXGRP: execute by group\nS_IRWXO: mask for others (not in group) permissions\nS_IROTH: read by others\nS_IWOTH: write by others\nS_IXOTH: execute by others\n\nUF_NODUMP: do not dump file\nUF_IMMUTABLE: file may not be changed\nUF_APPEND: file may only be appended to\nUF_OPAQUE: directory is opaque when viewed through a union stack\nUF_NOUNLINK: file may not be renamed or deleted\nUF_COMPRESSED: OS X: file is hfs-compressed\nUF_HIDDEN: OS X: file should not be displayed\nSF_ARCHIVED: file may be archived\nSF_IMMUTABLE: file may not be changed\nSF_APPEND: file may only be appended to\nSF_NOUNLINK: file may not be renamed or deleted\nSF_SNAPSHOT: file is a snapshot file\n\nST_MODE\nST_INO\nST_DEV\nST_NLINK\nST_UID\nST_GID\nST_SIZE\nST_ATIME\nST_MTIME\nST_CTIME\n\nFILE_ATTRIBUTE_*: Windows file attribute constants\n                   (only present on Windows)\n")),
    ("_stat.S_IFMT", Some("Return the portion of the file's mode that describes the file type.")),
    ("_stat.S_IMODE", Some("Return the portion of the file's mode that can be set by os.chmod().")),
    ("_stat.S_ISBLK", Some("S_ISBLK(mode) -> bool\n\nReturn True if mode is from a block special device file.")),
    ("_stat.S_ISCHR", Some("S_ISCHR(mode) -> bool\n\nReturn True if mode is from a character special device file.")),
    ("_stat.S_ISDIR", Some("S_ISDIR(mode) -> bool\n\nReturn True if mode is from a directory.")),
    ("_stat.S_ISDOOR", Some("S_ISDOOR(mode) -> bool\n\nReturn True if mode is from a door.")),
    ("_stat.S_ISFIFO", Some("S_ISFIFO(mode) -> bool\n\nReturn True if mode is from a FIFO (named pipe).")),
    ("_stat.S_ISLNK", Some("S_ISLNK(mode) -> bool\n\nReturn True if mode is from a symbolic link.")),
    ("_stat.S_ISPORT", Some("S_ISPORT(mode) -> bool\n\nReturn True if mode is from an event port.")),
    ("_stat.S_ISREG", Some("S_ISREG(mode) -> bool\n\nReturn True if mode is from a regular file.")),
    ("_stat.S_ISSOCK", Some("S_ISSOCK(mode) -> bool\n\nReturn True if mode is from a socket.")),
    ("_stat.S_ISWHT", Some("S_ISWHT(mode) -> bool\n\nReturn True if mode is from a whiteout.")),
    ("_stat.filemode", Some("Convert a file's mode to a string of the form '-rwxrwxrwx'")),
    ("_string", Some("string helper module")),
    ("_string.formatter_field_name_split", Some("split the argument as a field name")),
    ("_string.formatter_parser", Some("parse the argument as a format string")),
    ("_symtable.symtable", Some("Return symbol and scope dictionaries used internally by compiler.")),
    ("_thread", Some("This module provides primitive operations to write multi-threaded programs.\nThe 'threading' module provides a more convenient interface.")),
    ("_thread.LockType", Some("A lock object is a synchronization primitive.  To create a lock,\ncall threading.Lock().  Methods are:\n\nacquire() -- lock the lock, possibly blocking until it can be obtained\nrelease() -- unlock of the lock\nlocked() -- test whether the lock is currently locked\n\nA lock is not owned by the thread that locked it; another thread may\nunlock it.  A thread attempting to lock a lock that it has already locked\nwill block until another thread unlocks it.  Deadlocks may ensue.")),
    ("_thread.LockType.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_thread.LockType.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_thread.LockType.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_thread.RLock.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_thread.RLock.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_thread.RLock.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_thread._ExceptHookArgs", Some("ExceptHookArgs\n\nType used to pass arguments to threading.excepthook.")),
    ("_thread._ExceptHookArgs.__class_getitem__", Some("See PEP 585")),
    ("_thread._ExceptHookArgs.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_thread._ExceptHookArgs.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_thread._ExceptHookArgs.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_thread._count", Some("_count() -> integer\n\nReturn the number of currently running Python threads, excluding\nthe main thread. The returned number comprises all threads created\nthrough `start_new_thread()` as well as `threading.Thread`, and not\nyet finished.\n\nThis function is meant for internal and specialized purposes only.\nIn most applications `threading.enumerate()` should be used instead.")),
    ("_thread._excepthook", Some("excepthook(exc_type, exc_value, exc_traceback, thread)\n\nHandle uncaught Thread.run() exception.")),
    ("_thread._local", Some("Thread-local data")),
    ("_thread._local.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_thread._local.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_thread._local.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_thread._set_sentinel", Some("_set_sentinel() -> lock\n\nSet a sentinel lock that will be released when the current thread\nstate is finalized (after it is untied from the interpreter).\n\nThis is a private API for the threading module.")),
    ("_thread.allocate", Some("allocate_lock() -> lock object\n(allocate() is an obsolete synonym)\n\nCreate a new lock object. See help(type(threading.Lock())) for\ninformation about locks.")),
    ("_thread.allocate_lock", Some("allocate_lock() -> lock object\n(allocate() is an obsolete synonym)\n\nCreate a new lock object. See help(type(threading.Lock())) for\ninformation about locks.")),
    ("_thread.exit", Some("exit()\n(exit_thread() is an obsolete synonym)\n\nThis is synonymous to ``raise SystemExit''.  It will cause the current\nthread to exit silently unless the exception is caught.")),
    ("_thread.exit_thread", Some("exit()\n(exit_thread() is an obsolete synonym)\n\nThis is synonymous to ``raise SystemExit''.  It will cause the current\nthread to exit silently unless the exception is caught.")),
    ("_thread.get_ident", Some("get_ident() -> integer\n\nReturn a non-zero integer that uniquely identifies the current thread\namongst other threads that exist simultaneously.\nThis may be used to identify per-thread resources.\nEven though on some platforms threads identities may appear to be\nallocated consecutive numbers starting at 1, this behavior should not\nbe relied upon, and the number should be seen purely as a magic cookie.\nA thread's identity may be reused for another thread after it exits.")),
    ("_thread.get_native_id", Some("get_native_id() -> integer\n\nReturn a non-negative integer identifying the thread as reported\nby the OS (kernel). This may be used to uniquely identify a\nparticular thread within a system.")),
    ("_thread.interrupt_main", Some("interrupt_main(signum=signal.SIGINT, /)\n\nSimulate the arrival of the given signal in the main thread,\nwhere the corresponding signal handler will be executed.\nIf *signum* is omitted, SIGINT is assumed.\nA subthread can use this function to interrupt the main thread.\n\nNote: the default signal handler for SIGINT raises ``KeyboardInterrupt``.")),
    ("_thread.stack_size", Some("stack_size([size]) -> size\n\nReturn the thread stack size used when creating new threads.  The\noptional size argument specifies the stack size (in bytes) to be used\nfor subsequently created threads, and must be 0 (use platform or\nconfigured default) or a positive integer value of at least 32,768 (32k).\nIf changing the thread stack size is unsupported, a ThreadError\nexception is raised.  If the specified size is invalid, a ValueError\nexception is raised, and the stack size is unmodified.  32k bytes\n currently the minimum supported stack size value to guarantee\nsufficient stack space for the interpreter itself.\n\nNote that some platforms may have particular restrictions on values for\nthe stack size, such as requiring a minimum stack size larger than 32 KiB or\nrequiring allocation in multiples of the system memory page size\n- platform documentation should be referred to for more information\n(4 KiB pages are common; using multiples of 4096 for the stack size is\nthe suggested approach in the absence of more specific information).")),
    ("_thread.start_new", Some("start_new_thread(function, args[, kwargs])\n(start_new() is an obsolete synonym)\n\nStart a new thread and return its identifier.  The thread will call the\nfunction with positional arguments from the tuple args and keyword arguments\ntaken from the optional dictionary kwargs.  The thread exits when the\nfunction returns; the return value is ignored.  The thread will also exit\nwhen the function raises an unhandled exception; a stack trace will be\nprinted unless the exception is SystemExit.\n")),
    ("_thread.start_new_thread", Some("start_new_thread(function, args[, kwargs])\n(start_new() is an obsolete synonym)\n\nStart a new thread and return its identifier.  The thread will call the\nfunction with positional arguments from the tuple args and keyword arguments\ntaken from the optional dictionary kwargs.  The thread exits when the\nfunction returns; the return value is ignored.  The thread will also exit\nwhen the function raises an unhandled exception; a stack trace will be\nprinted unless the exception is SystemExit.\n")),
    ("_tokenize.TokenizerIter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_tokenize.TokenizerIter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_tokenize.TokenizerIter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_warnings", Some("_warnings provides basic warning filtering support.\nIt is a helper module to speed up interpreter start-up.")),
    ("_warnings._filters_mutated", None),
    ("_warnings.warn", Some("Issue a warning, or maybe ignore it or raise an exception.")),
    ("_warnings.warn_explicit", Some("Low-level interface to warnings functionality.")),
    ("_weakref", Some("Weak-reference support module.")),
    ("_weakref._remove_dead_weakref", Some("Atomically remove key from dict if it points to a dead weakref.")),
    ("_weakref.getweakrefcount", Some("Return the number of weak references to 'object'.")),
    ("_weakref.getweakrefs", Some("Return a list of all weak reference objects pointing to 'object'.")),
    ("_weakref.proxy", Some("Create a proxy object that weakly references 'object'.\n\n'callback', if given, is called with a reference to the\nproxy when 'object' is about to be finalized.")),
    ("atexit", Some("allow programmer to define multiple exit functions to be executed\nupon normal program termination.\n\nTwo public functions, register and unregister, are defined.\n")),
    ("atexit._clear", Some("_clear() -> None\n\nClear the list of previously registered exit functions.")),
    ("atexit._ncallbacks", Some("_ncallbacks() -> int\n\nReturn the number of registered exit functions.")),
    ("atexit._run_exitfuncs", Some("_run_exitfuncs() -> None\n\nRun all registered exit functions.\n\nIf a callback raises an exception, it is logged with sys.unraisablehook.")),
    ("atexit.register", Some("register(func, *args, **kwargs) -> func\n\nRegister a function to be executed upon normal program termination\n\n    func - function to be called at exit\n    args - optional arguments to pass to func\n    kwargs - optional keyword arguments to pass to func\n\n    func is returned to facilitate usage as a decorator.")),
    ("atexit.unregister", Some("unregister(func) -> None\n\nUnregister an exit function which was previously registered using\natexit.register\n\n    func - function to be unregistered")),
    ("builtins", Some("Built-in functions, types, exceptions, and other objects.\n\nThis module provides direct access to all 'built-in'\nidentifiers of Python; for example, builtins.len is\nthe full name for the built-in function len().\n\nThis module is not normally accessed explicitly by most\napplications, but can be useful in modules that provide\nobjects with the same name as a built-in value, but in\nwhich the built-in of that name is also needed.")),
    ("builtins.ArithmeticError", Some("Base class for arithmetic errors.")),
    ("builtins.ArithmeticError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ArithmeticError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ArithmeticError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.AssertionError", Some("Assertion failed.")),
    ("builtins.AssertionError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.AssertionError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.AssertionError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.AttributeError", Some("Attribute not found.")),
    ("builtins.AttributeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.AttributeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.AttributeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.BaseException", Some("Common base class for all exceptions")),
    ("builtins.BaseException.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.BaseException.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.BaseException.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.BaseExceptionGroup", Some("A combination of multiple unrelated exceptions.")),
    ("builtins.BaseExceptionGroup.__class_getitem__", Some("See PEP 585")),
    ("builtins.BaseExceptionGroup.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.BaseExceptionGroup.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.BaseExceptionGroup.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.BlockingIOError", Some("I/O operation would block.")),
    ("builtins.BlockingIOError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.BlockingIOError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.BlockingIOError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.BrokenPipeError", Some("Broken pipe.")),
    ("builtins.BrokenPipeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.BrokenPipeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.BrokenPipeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.BufferError", Some("Buffer error.")),
    ("builtins.BufferError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.BufferError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.BufferError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.BytesWarning", Some("Base class for warnings about bytes and buffer related problems, mostly\nrelated to conversion from str or comparing to str.")),
    ("builtins.BytesWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.BytesWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.BytesWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ChildProcessError", Some("Child process error.")),
    ("builtins.ChildProcessError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ChildProcessError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ChildProcessError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ConnectionAbortedError", Some("Connection aborted.")),
    ("builtins.ConnectionAbortedError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ConnectionAbortedError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ConnectionAbortedError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ConnectionError", Some("Connection error.")),
    ("builtins.ConnectionError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ConnectionError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ConnectionError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ConnectionRefusedError", Some("Connection refused.")),
    ("builtins.ConnectionRefusedError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ConnectionRefusedError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ConnectionRefusedError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ConnectionResetError", Some("Connection reset.")),
    ("builtins.ConnectionResetError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ConnectionResetError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ConnectionResetError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.DeprecationWarning", Some("Base class for warnings about deprecated features.")),
    ("builtins.DeprecationWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.DeprecationWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.DeprecationWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.EOFError", Some("Read beyond end of file.")),
    ("builtins.EOFError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.EOFError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.EOFError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.EncodingWarning", Some("Base class for warnings about encodings.")),
    ("builtins.EncodingWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.EncodingWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.EncodingWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.EnvironmentError", Some("Base class for I/O related errors.")),
    ("builtins.EnvironmentError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.EnvironmentError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.EnvironmentError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.Exception", Some("Common base class for all non-exit exceptions.")),
    ("builtins.Exception.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.Exception.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.Exception.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ExceptionGroup.__class_getitem__", Some("See PEP 585")),
    ("builtins.ExceptionGroup.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ExceptionGroup.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ExceptionGroup.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.FileExistsError", Some("File already exists.")),
    ("builtins.FileExistsError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.FileExistsError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.FileExistsError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.FileNotFoundError", Some("File not found.")),
    ("builtins.FileNotFoundError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.FileNotFoundError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.FileNotFoundError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.FloatingPointError", Some("Floating point operation failed.")),
    ("builtins.FloatingPointError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.FloatingPointError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.FloatingPointError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.FutureWarning", Some("Base class for warnings about constructs that will change semantically\nin the future.")),
    ("builtins.FutureWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.FutureWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.FutureWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.GeneratorExit", Some("Request that a generator exit.")),
    ("builtins.GeneratorExit.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.GeneratorExit.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.GeneratorExit.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.IOError", Some("Base class for I/O related errors.")),
    ("builtins.IOError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.IOError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.IOError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ImportError", Some("Import can't find module, or can't find name in module.")),
    ("builtins.ImportError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ImportError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ImportError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ImportWarning", Some("Base class for warnings about probable mistakes in module imports")),
    ("builtins.ImportWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ImportWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ImportWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.IndentationError", Some("Improper indentation.")),
    ("builtins.IndentationError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.IndentationError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.IndentationError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.IndexError", Some("Sequence index out of range.")),
    ("builtins.IndexError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.IndexError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.IndexError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.InterruptedError", Some("Interrupted by signal.")),
    ("builtins.InterruptedError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.InterruptedError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.InterruptedError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.IsADirectoryError", Some("Operation doesn't work on directories.")),
    ("builtins.IsADirectoryError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.IsADirectoryError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.IsADirectoryError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.KeyError", Some("Mapping key not found.")),
    ("builtins.KeyError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.KeyError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.KeyError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.KeyboardInterrupt", Some("Program interrupted by user.")),
    ("builtins.KeyboardInterrupt.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.KeyboardInterrupt.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.KeyboardInterrupt.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.LookupError", Some("Base class for lookup errors.")),
    ("builtins.LookupError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.LookupError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.LookupError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.MemoryError", Some("Out of memory.")),
    ("builtins.MemoryError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.MemoryError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.MemoryError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ModuleNotFoundError", Some("Module not found.")),
    ("builtins.ModuleNotFoundError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ModuleNotFoundError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ModuleNotFoundError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.NameError", Some("Name not found globally.")),
    ("builtins.NameError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.NameError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.NameError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.NotADirectoryError", Some("Operation only works on directories.")),
    ("builtins.NotADirectoryError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.NotADirectoryError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.NotADirectoryError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.NotImplementedError", Some("Method or function hasn't been implemented yet.")),
    ("builtins.NotImplementedError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.NotImplementedError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.NotImplementedError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.OSError", Some("Base class for I/O related errors.")),
    ("builtins.OSError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.OSError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.OSError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.OverflowError", Some("Result too large to be represented.")),
    ("builtins.OverflowError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.OverflowError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.OverflowError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.PendingDeprecationWarning", Some("Base class for warnings about features which will be deprecated\nin the future.")),
    ("builtins.PendingDeprecationWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.PendingDeprecationWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.PendingDeprecationWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.PermissionError", Some("Not enough permissions.")),
    ("builtins.PermissionError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.PermissionError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.PermissionError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ProcessLookupError", Some("Process not found.")),
    ("builtins.ProcessLookupError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ProcessLookupError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ProcessLookupError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.RecursionError", Some("Recursion limit exceeded.")),
    ("builtins.RecursionError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.RecursionError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.RecursionError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ReferenceError", Some("Weak ref proxy used after referent went away.")),
    ("builtins.ReferenceError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ReferenceError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ReferenceError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ResourceWarning", Some("Base class for warnings about resource usage.")),
    ("builtins.ResourceWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ResourceWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ResourceWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.RuntimeError", Some("Unspecified run-time error.")),
    ("builtins.RuntimeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.RuntimeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.RuntimeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.RuntimeWarning", Some("Base class for warnings about dubious runtime behavior.")),
    ("builtins.RuntimeWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.RuntimeWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.RuntimeWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.StopAsyncIteration", Some("Signal the end from iterator.__anext__().")),
    ("builtins.StopAsyncIteration.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.StopAsyncIteration.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.StopAsyncIteration.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.StopIteration", Some("Signal the end from iterator.__next__().")),
    ("builtins.StopIteration.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.StopIteration.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.StopIteration.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.SyntaxError", Some("Invalid syntax.")),
    ("builtins.SyntaxError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.SyntaxError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.SyntaxError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.SyntaxWarning", Some("Base class for warnings about dubious syntax.")),
    ("builtins.SyntaxWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.SyntaxWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.SyntaxWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.SystemError", Some("Internal error in the Python interpreter.\n\nPlease report this to the Python maintainer, along with the traceback,\nthe Python version, and the hardware/OS platform and version.")),
    ("builtins.SystemError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.SystemError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.SystemError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.SystemExit", Some("Request to exit from the interpreter.")),
    ("builtins.SystemExit.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.SystemExit.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.SystemExit.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.TabError", Some("Improper mixture of spaces and tabs.")),
    ("builtins.TabError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.TabError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.TabError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.TimeoutError", Some("Timeout expired.")),
    ("builtins.TimeoutError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.TimeoutError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.TimeoutError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.TypeError", Some("Inappropriate argument type.")),
    ("builtins.TypeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.TypeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.TypeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UnboundLocalError", Some("Local name referenced but not bound to a value.")),
    ("builtins.UnboundLocalError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UnboundLocalError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UnboundLocalError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UnicodeDecodeError", Some("Unicode decoding error.")),
    ("builtins.UnicodeDecodeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UnicodeDecodeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UnicodeDecodeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UnicodeEncodeError", Some("Unicode encoding error.")),
    ("builtins.UnicodeEncodeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UnicodeEncodeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UnicodeEncodeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UnicodeError", Some("Unicode related error.")),
    ("builtins.UnicodeError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UnicodeError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UnicodeError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UnicodeTranslateError", Some("Unicode translation error.")),
    ("builtins.UnicodeTranslateError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UnicodeTranslateError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UnicodeTranslateError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UnicodeWarning", Some("Base class for warnings about Unicode related problems, mostly\nrelated to conversion problems.")),
    ("builtins.UnicodeWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UnicodeWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UnicodeWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.UserWarning", Some("Base class for warnings generated by user code.")),
    ("builtins.UserWarning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.UserWarning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.UserWarning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ValueError", Some("Inappropriate argument value (of correct type).")),
    ("builtins.ValueError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ValueError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ValueError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.Warning", Some("Base class for warning categories.")),
    ("builtins.Warning.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.Warning.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.Warning.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.ZeroDivisionError", Some("Second argument to a division or modulo operation was zero.")),
    ("builtins.ZeroDivisionError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.ZeroDivisionError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.ZeroDivisionError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.__build_class__", Some("__build_class__(func, name, /, *bases, [metaclass], **kwds) -> class\n\nInternal helper function used by the class statement.")),
    ("builtins.__import__", Some("Import a module.\n\nBecause this function is meant for use by the Python\ninterpreter and not for general use, it is better to use\nimportlib.import_module() to programmatically import a module.\n\nThe globals argument is only used to determine the context;\nthey are not modified.  The locals argument is unused.  The fromlist\nshould be a list of names to emulate ``from name import ...``, or an\nempty list to emulate ``import name``.\nWhen importing a module from a package, note that __import__('A.B', ...)\nreturns package A when fromlist is empty, but its submodule B when\nfromlist is not empty.  The level argument is used to determine whether to\nperform absolute or relative imports: 0 is absolute, while a positive number\nis the number of parent directories to search relative to the current module.")),
    ("builtins.abs", Some("Return the absolute value of the argument.")),
    ("builtins.aiter", Some("Return an AsyncIterator for an AsyncIterable object.")),
    ("builtins.all", Some("Return True if bool(x) is True for all values x in the iterable.\n\nIf the iterable is empty, return True.")),
    ("builtins.anext", Some("async anext(aiterator[, default])\n\nReturn the next item from the async iterator.  If default is given and the async\niterator is exhausted, it is returned instead of raising StopAsyncIteration.")),
    ("builtins.any", Some("Return True if bool(x) is True for any x in the iterable.\n\nIf the iterable is empty, return False.")),
    ("builtins.ascii", Some("Return an ASCII-only representation of an object.\n\nAs repr(), return a string containing a printable representation of an\nobject, but escape the non-ASCII characters in the string returned by\nrepr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\nto that returned by repr() in Python 2.")),
    ("builtins.bin", Some("Return the binary representation of an integer.\n\n   >>> bin(2796202)\n   '0b1010101010101010101010'")),
    ("builtins.bool", Some("bool(x) -> bool\n\nReturns True when the argument x is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.")),
    ("builtins.bool.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.bool.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.bool.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.bool.from_bytes", Some("Return the integer represented by the given array of bytes.\n\n  bytes\n    Holds the array of bytes to convert.  The argument must either\n    support the buffer protocol or be an iterable object producing bytes.\n    Bytes and bytearray are examples of built-in objects that support the\n    buffer protocol.\n  byteorder\n    The byte order used to represent the integer.  If byteorder is 'big',\n    the most significant byte is at the beginning of the byte array.  If\n    byteorder is 'little', the most significant byte is at the end of the\n    byte array.  To request the native byte order of the host system, use\n    `sys.byteorder' as the byte order value.  Default is to use 'big'.\n  signed\n    Indicates whether two's complement is used to represent the integer.")),
    ("builtins.breakpoint", Some("breakpoint(*args, **kws)\n\nCall sys.breakpointhook(*args, **kws).  sys.breakpointhook() must accept\nwhatever arguments are passed.\n\nBy default, this drops you into the pdb debugger.")),
    ("builtins.bytearray", Some("bytearray(iterable_of_ints) -> bytearray\nbytearray(string, encoding[, errors]) -> bytearray\nbytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer\nbytearray(int) -> bytes array of size given by the parameter initialized with null bytes\nbytearray() -> empty bytes array\n\nConstruct a mutable bytearray object from:\n  - an iterable yielding integers in range(256)\n  - a text string encoded using the specified encoding\n  - a bytes or a buffer object\n  - any object implementing the buffer API.\n  - an integer")),
    ("builtins.bytearray.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.bytearray.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.bytearray.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.bytearray.fromhex", Some("Create a bytearray object from a string of hexadecimal numbers.\n\nSpaces between two numbers are accepted.\nExample: bytearray.fromhex('B9 01EF') -> bytearray(b'\\\\xb9\\\\x01\\\\xef')")),
    ("builtins.bytearray.maketrans", Some("Return a translation table useable for the bytes or bytearray translate method.\n\nThe returned table will be one where each byte in frm is mapped to the byte at\nthe same position in to.\n\nThe bytes objects frm and to must be of the same length.")),
    ("builtins.bytes", Some("bytes(iterable_of_ints) -> bytes\nbytes(string, encoding[, errors]) -> bytes\nbytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer\nbytes(int) -> bytes object of size given by the parameter initialized with null bytes\nbytes() -> empty bytes object\n\nConstruct an immutable array of bytes from:\n  - an iterable yielding integers in range(256)\n  - a text string encoded using the specified encoding\n  - any object implementing the buffer API.\n  - an integer")),
    ("builtins.bytes.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.bytes.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.bytes.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.bytes.fromhex", Some("Create a bytes object from a string of hexadecimal numbers.\n\nSpaces between two numbers are accepted.\nExample: bytes.fromhex('B9 01EF') -> b'\\\\xb9\\\\x01\\\\xef'.")),
    ("builtins.bytes.maketrans", Some("Return a translation table useable for the bytes or bytearray translate method.\n\nThe returned table will be one where each byte in frm is mapped to the byte at\nthe same position in to.\n\nThe bytes objects frm and to must be of the same length.")),
    ("builtins.callable", Some("Return whether the object is callable (i.e., some kind of function).\n\nNote that classes are callable, as are instances of classes with a\n__call__() method.")),
    ("builtins.chr", Some("Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.")),
    ("builtins.classmethod", Some("classmethod(function) -> method\n\nConvert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n  class C:\n      @classmethod\n      def f(cls, arg1, arg2, argN):\n          ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()).  The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin.")),
    ("builtins.classmethod.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.classmethod.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.classmethod.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.compile", Some("Compile source into a code object that can be executed by exec() or eval().\n\nThe source code may represent a Python module, statement or expression.\nThe filename will be used for run-time error messages.\nThe mode must be 'exec' to compile a module, 'single' to compile a\nsingle (interactive) statement, or 'eval' to compile an expression.\nThe flags argument, if present, controls which future statements influence\nthe compilation of the code.\nThe dont_inherit argument, if true, stops the compilation inheriting\nthe effects of any future statements in effect in the code calling\ncompile; if absent or false these statements do influence the compilation,\nin addition to any features explicitly specified.")),
    ("builtins.complex", Some("Create a complex number from a real part and an optional imaginary part.\n\nThis is equivalent to (real + imag*1j) where imag defaults to 0.")),
    ("builtins.complex.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.complex.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.complex.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.delattr", Some("Deletes the named attribute from the given object.\n\ndelattr(x, 'y') is equivalent to ``del x.y``")),
    ("builtins.dict", Some("dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n    (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n    d = {}\n    for k, v in iterable:\n        d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n    in the keyword argument list.  For example:  dict(one=1, two=2)")),
    ("builtins.dict.__class_getitem__", Some("See PEP 585")),
    ("builtins.dict.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.dict.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.dict.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.dict.fromkeys", Some("Create a new dictionary with keys from iterable and values set to value.")),
    ("builtins.dir", Some("dir([object]) -> list of strings\n\nIf called without an argument, return the names in the current scope.\nElse, return an alphabetized list of names comprising (some of) the attributes\nof the given object, and of attributes reachable from it.\nIf the object supplies a method named __dir__, it will be used; otherwise\nthe default dir() logic is used and returns:\n  for a module object: the module's attributes.\n  for a class object:  its attributes, and recursively the attributes\n    of its bases.\n  for any other object: its attributes, its class's attributes, and\n    recursively the attributes of its class's base classes.")),
    ("builtins.divmod", Some("Return the tuple (x//y, x%y).  Invariant: div*y + mod == x.")),
    ("builtins.enumerate", Some("Return an enumerate object.\n\n  iterable\n    an object supporting iteration\n\nThe enumerate object yields pairs containing a count (from start, which\ndefaults to zero) and a value yielded by the iterable argument.\n\nenumerate is useful for obtaining an indexed list:\n    (0, seq[0]), (1, seq[1]), (2, seq[2]), ...")),
    ("builtins.enumerate.__class_getitem__", Some("See PEP 585")),
    ("builtins.enumerate.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.enumerate.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.enumerate.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.eval", Some("Evaluate the given source in the context of globals and locals.\n\nThe source may be a string representing a Python expression\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.")),
    ("builtins.exec", Some("Execute the given source in the context of globals and locals.\n\nThe source may be a string representing one or more Python statements\nor a code object as returned by compile().\nThe globals must be a dictionary and locals can be any mapping,\ndefaulting to the current globals and locals.\nIf only globals is given, locals defaults to it.\nThe closure must be a tuple of cellvars, and can only be used\nwhen source is a code object requiring exactly that many cellvars.")),
    ("builtins.filter", Some("filter(function or None, iterable) --> filter object\n\nReturn an iterator yielding those items of iterable for which function(item)\nis true. If function is None, return the items that are true.")),
    ("builtins.filter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.filter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.filter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.float", Some("Convert a string or number to a floating point number, if possible.")),
    ("builtins.float.__getformat__", Some("You probably don't want to use this function.\n\n  typestr\n    Must be 'double' or 'float'.\n\nIt exists mainly to be used in Python's test suite.\n\nThis function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,\nlittle-endian' best describes the format of floating point numbers used by the\nC type named by typestr.")),
    ("builtins.float.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.float.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.float.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.float.fromhex", Some("Create a floating-point number from a hexadecimal string.\n\n>>> float.fromhex('0x1.ffffp10')\n2047.984375\n>>> float.fromhex('-0x1p-1074')\n-5e-324")),
    ("builtins.format", Some("Return value.__format__(format_spec)\n\nformat_spec defaults to the empty string.\nSee the Format Specification Mini-Language section of help('FORMATTING') for\ndetails.")),
    ("builtins.frozenset", Some("frozenset() -> empty frozenset object\nfrozenset(iterable) -> frozenset object\n\nBuild an immutable unordered collection of unique elements.")),
    ("builtins.frozenset.__class_getitem__", Some("See PEP 585")),
    ("builtins.frozenset.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.frozenset.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.frozenset.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.getattr", Some("getattr(object, name[, default]) -> value\n\nGet a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\nWhen a default argument is given, it is returned when the attribute doesn't\nexist; without it, an exception is raised in that case.")),
    ("builtins.globals", Some("Return the dictionary containing the current scope's global variables.\n\nNOTE: Updates to this dictionary *will* affect name lookups in the current\nglobal scope and vice-versa.")),
    ("builtins.hasattr", Some("Return whether the object has an attribute with the given name.\n\nThis is done by calling getattr(obj, name) and catching AttributeError.")),
    ("builtins.hash", Some("Return the hash value for the given object.\n\nTwo objects that compare equal must also have the same hash value, but the\nreverse is not necessarily true.")),
    ("builtins.hex", Some("Return the hexadecimal representation of an integer.\n\n   >>> hex(12648430)\n   '0xc0ffee'")),
    ("builtins.id", Some("Return the identity of an object.\n\nThis is guaranteed to be unique among simultaneously existing objects.\n(CPython uses the object's memory address.)")),
    ("builtins.input", Some("Read a string from standard input.  The trailing newline is stripped.\n\nThe prompt string, if given, is printed to standard output without a\ntrailing newline before reading input.\n\nIf the user hits EOF (*nix: Ctrl-D, Windows: Ctrl-Z+Return), raise EOFError.\nOn *nix systems, readline is used if available.")),
    ("builtins.int", Some("int([x]) -> integer\nint(x, base=10) -> integer\n\nConvert a number or string to an integer, or return 0 if no arguments\nare given.  If x is a number, return x.__int__().  For floating point\nnumbers, this truncates towards zero.\n\nIf x is not a number or if base is given, then x must be a string,\nbytes, or bytearray instance representing an integer literal in the\ngiven base.  The literal can be preceded by '+' or '-' and be surrounded\nby whitespace.  The base defaults to 10.  Valid bases are 0 and 2-36.\nBase 0 means to interpret the base from the string as an integer literal.\n>>> int('0b100', base=0)\n4")),
    ("builtins.int.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.int.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.int.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.int.from_bytes", Some("Return the integer represented by the given array of bytes.\n\n  bytes\n    Holds the array of bytes to convert.  The argument must either\n    support the buffer protocol or be an iterable object producing bytes.\n    Bytes and bytearray are examples of built-in objects that support the\n    buffer protocol.\n  byteorder\n    The byte order used to represent the integer.  If byteorder is 'big',\n    the most significant byte is at the beginning of the byte array.  If\n    byteorder is 'little', the most significant byte is at the end of the\n    byte array.  To request the native byte order of the host system, use\n    `sys.byteorder' as the byte order value.  Default is to use 'big'.\n  signed\n    Indicates whether two's complement is used to represent the integer.")),
    ("builtins.isinstance", Some("Return whether an object is an instance of a class or of a subclass thereof.\n\nA tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)\nor ...`` etc.")),
    ("builtins.issubclass", Some("Return whether 'cls' is derived from another class or is the same class.\n\nA tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to\ncheck against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)\nor ...``.")),
    ("builtins.iter", Some("iter(iterable) -> iterator\niter(callable, sentinel) -> iterator\n\nGet an iterator from an object.  In the first form, the argument must\nsupply its own iterator, or be a sequence.\nIn the second form, the callable is called until it returns the sentinel.")),
    ("builtins.len", Some("Return the number of items in a container.")),
    ("builtins.list", Some("Built-in mutable sequence.\n\nIf no argument is given, the constructor creates a new empty list.\nThe argument must be an iterable if specified.")),
    ("builtins.list.__class_getitem__", Some("See PEP 585")),
    ("builtins.list.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.list.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.list.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.locals", Some("Return a dictionary containing the current scope's local variables.\n\nNOTE: Whether or not updates to this dictionary will affect name lookups in\nthe local scope and vice-versa is *implementation dependent* and not\ncovered by any backwards compatibility guarantees.")),
    ("builtins.map", Some("map(func, *iterables) --> map object\n\nMake an iterator that computes the function using arguments from\neach of the iterables.  Stops when the shortest iterable is exhausted.")),
    ("builtins.map.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.map.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.map.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.max", Some("max(iterable, *[, default=obj, key=func]) -> value\nmax(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its biggest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more arguments, return the largest argument.")),
    ("builtins.memoryview", Some("Create a new memoryview object which references the given object.")),
    ("builtins.memoryview.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.memoryview.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.memoryview.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.min", Some("min(iterable, *[, default=obj, key=func]) -> value\nmin(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its smallest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more arguments, return the smallest argument.")),
    ("builtins.next", Some("next(iterator[, default])\n\nReturn the next item from the iterator. If default is given and the iterator\nis exhausted, it is returned instead of raising StopIteration.")),
    ("builtins.object", Some("The base class of the class hierarchy.\n\nWhen called, it accepts no arguments and returns a new featureless\ninstance that has no instance attributes and cannot be given any.\n")),
    ("builtins.object.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.object.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.object.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.oct", Some("Return the octal representation of an integer.\n\n   >>> oct(342391)\n   '0o1234567'")),
    ("builtins.ord", Some("Return the Unicode code point for a one-character string.")),
    ("builtins.pow", Some("Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments\n\nSome types, such as ints, are able to use a more efficient algorithm when\ninvoked using the three argument form.")),
    ("builtins.print", Some("Prints the values to a stream, or to sys.stdout by default.\n\n  sep\n    string inserted between values, default a space.\n  end\n    string appended after the last value, default a newline.\n  file\n    a file-like object (stream); defaults to the current sys.stdout.\n  flush\n    whether to forcibly flush the stream.")),
    ("builtins.property", Some("Property attribute.\n\n  fget\n    function to be used for getting an attribute value\n  fset\n    function to be used for setting an attribute value\n  fdel\n    function to be used for del'ing an attribute\n  doc\n    docstring\n\nTypical use is to define a managed attribute x:\n\nclass C(object):\n    def getx(self): return self._x\n    def setx(self, value): self._x = value\n    def delx(self): del self._x\n    x = property(getx, setx, delx, \"I'm the 'x' property.\")\n\nDecorators make defining new properties or modifying existing ones easy:\n\nclass C(object):\n    @property\n    def x(self):\n        \"I am the 'x' property.\"\n        return self._x\n    @x.setter\n    def x(self, value):\n        self._x = value\n    @x.deleter\n    def x(self):\n        del self._x")),
    ("builtins.property.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.property.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.property.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.range", Some("range(stop) -> range object\nrange(start, stop[, step]) -> range object\n\nReturn an object that produces a sequence of integers from start (inclusive)\nto stop (exclusive) by step.  range(i, j) produces i, i+1, i+2, ..., j-1.\nstart defaults to 0, and stop is omitted!  range(4) produces 0, 1, 2, 3.\nThese are exactly the valid indices for a list of 4 elements.\nWhen step is given, it specifies the increment (or decrement).")),
    ("builtins.range.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.range.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.range.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.repr", Some("Return the canonical string representation of the object.\n\nFor many object types, including most builtins, eval(repr(obj)) == obj.")),
    ("builtins.reversed", Some("Return a reverse iterator over the values of the given sequence.")),
    ("builtins.reversed.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.reversed.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.reversed.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.round", Some("Round a number to a given precision in decimal digits.\n\nThe return value is an integer if ndigits is omitted or None.  Otherwise\nthe return value has the same type as the number.  ndigits may be negative.")),
    ("builtins.set", Some("set() -> new empty set object\nset(iterable) -> new set object\n\nBuild an unordered collection of unique elements.")),
    ("builtins.set.__class_getitem__", Some("See PEP 585")),
    ("builtins.set.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.set.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.set.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.setattr", Some("Sets the named attribute on the given object to the specified value.\n\nsetattr(x, 'y', v) is equivalent to ``x.y = v``")),
    ("builtins.slice", Some("slice(stop)\nslice(start, stop[, step])\n\nCreate a slice object.  This is used for extended slicing (e.g. a[0:10:2]).")),
    ("builtins.slice.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.slice.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.slice.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.sorted", Some("Return a new list containing all items from the iterable in ascending order.\n\nA custom key function can be supplied to customize the sort order, and the\nreverse flag can be set to request the result in descending order.")),
    ("builtins.staticmethod", Some("staticmethod(function) -> method\n\nConvert a function to be a static method.\n\nA static method does not receive an implicit first argument.\nTo declare a static method, use this idiom:\n\n     class C:\n         @staticmethod\n         def f(arg1, arg2, argN):\n             ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). Both the class and the instance are ignored, and\nneither is passed implicitly as the first argument to the method.\n\nStatic methods in Python are similar to those found in Java or C++.\nFor a more advanced concept, see the classmethod builtin.")),
    ("builtins.staticmethod.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.staticmethod.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.staticmethod.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.str", Some("str(object='') -> str\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\n\nCreate a new string object from the given object. If encoding or\nerrors is specified, then the object must expose a data buffer\nthat will be decoded using the given encoding and error handler.\nOtherwise, returns the result of object.__str__() (if defined)\nor repr(object).\nencoding defaults to sys.getdefaultencoding().\nerrors defaults to 'strict'.")),
    ("builtins.str.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.str.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.str.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.str.maketrans", Some("Return a translation table usable for str.translate().\n\nIf there is only one argument, it must be a dictionary mapping Unicode\nordinals (integers) or characters to Unicode ordinals, strings or None.\nCharacter keys will be then converted to ordinals.\nIf there are two arguments, they must be strings of equal length, and\nin the resulting dictionary, each character in x will be mapped to the\ncharacter at the same position in y. If there is a third argument, it\nmust be a string, whose characters will be mapped to None in the result.")),
    ("builtins.sum", Some("Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n\nWhen the iterable is empty, return the start value.\nThis function is intended specifically for use with numeric values and may\nreject non-numeric types.")),
    ("builtins.super", Some("super() -> same as super(__class__, <first argument>)\nsuper(type) -> unbound super object\nsuper(type, obj) -> bound super object; requires isinstance(obj, type)\nsuper(type, type2) -> bound super object; requires issubclass(type2, type)\nTypical use to call a cooperative superclass method:\nclass C(B):\n    def meth(self, arg):\n        super().meth(arg)\nThis works for class methods too:\nclass C(B):\n    @classmethod\n    def cmeth(cls, arg):\n        super().cmeth(arg)\n")),
    ("builtins.super.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.super.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.super.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.tuple", Some("Built-in immutable sequence.\n\nIf no argument is given, the constructor returns an empty tuple.\nIf iterable is specified the tuple is initialized from iterable's items.\n\nIf the argument is a tuple, the return value is the same object.")),
    ("builtins.tuple.__class_getitem__", Some("See PEP 585")),
    ("builtins.tuple.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.tuple.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.tuple.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.type", Some("type(object) -> the object's type\ntype(name, bases, dict, **kwds) -> a new type")),
    ("builtins.type.__base__", Some("The base class of the class hierarchy.\n\nWhen called, it accepts no arguments and returns a new featureless\ninstance that has no instance attributes and cannot be given any.\n")),
    ("builtins.type.__base__.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.type.__base__.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.type.__base__.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.type.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.type.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.type.__prepare__", Some("__prepare__() -> dict\nused to create the namespace for the class statement")),
    ("builtins.type.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.vars", Some("vars([object]) -> dictionary\n\nWithout arguments, equivalent to locals().\nWith an argument, equivalent to object.__dict__.")),
    ("builtins.zip", Some("zip(*iterables, strict=False) --> Yield tuples until an input is exhausted.\n\n   >>> list(zip('abcdefg', range(3), range(4)))\n   [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]\n\nThe zip object yields n-length tuples, where n is the number of iterables\npassed as positional arguments to zip().  The i-th element in every tuple\ncomes from the i-th iterable argument to zip().  This continues until the\nshortest argument is exhausted.\n\nIf strict is true and one of the arguments is exhausted before the others,\nraise a ValueError.")),
    ("builtins.zip.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.zip.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.zip.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("errno", Some("This module makes available standard errno system symbols.\n\nThe value of each symbol is the corresponding integer value,\ne.g., on most systems, errno.ENOENT equals the integer 2.\n\nThe dictionary errno.errorcode maps numeric codes to symbol names,\ne.g., errno.errorcode[2] could be the string 'ENOENT'.\n\nSymbols that are not relevant to the underlying system are not defined.\n\nTo map error codes to error messages, use the function os.strerror(),\ne.g. os.strerror(2) could return 'No such file or directory'.")),
    ("faulthandler", Some("faulthandler module.")),
    ("faulthandler._fatal_error_c_thread", Some("fatal_error_c_thread(): call Py_FatalError() in a new C thread.")),
    ("faulthandler._read_null", Some("_read_null(): read from NULL, raise a SIGSEGV or SIGBUS signal depending on the platform")),
    ("faulthandler._sigabrt", Some("_sigabrt(): raise a SIGABRT signal")),
    ("faulthandler._sigfpe", Some("_sigfpe(): raise a SIGFPE signal")),
    ("faulthandler._sigsegv", Some("_sigsegv(release_gil=False): raise a SIGSEGV signal")),
    ("faulthandler._stack_overflow", Some("_stack_overflow(): recursive call to raise a stack overflow")),
    ("faulthandler.cancel_dump_traceback_later", Some("cancel_dump_traceback_later():\ncancel the previous call to dump_traceback_later().")),
    ("faulthandler.disable", Some("disable(): disable the fault handler")),
    ("faulthandler.dump_traceback", Some("dump_traceback(file=sys.stderr, all_threads=True): dump the traceback of the current thread, or of all threads if all_threads is True, into file")),
    ("faulthandler.dump_traceback_later", Some("dump_traceback_later(timeout, repeat=False, file=sys.stderrn, exit=False):\ndump the traceback of all threads in timeout seconds,\nor each timeout seconds if repeat is True. If exit is True, call _exit(1) which is not safe.")),
    ("faulthandler.enable", Some("enable(file=sys.stderr, all_threads=True): enable the fault handler")),
    ("faulthandler.is_enabled", Some("is_enabled()->bool: check if the handler is enabled")),
    ("faulthandler.register", Some("register(signum, file=sys.stderr, all_threads=True, chain=False): register a handler for the signal 'signum': dump the traceback of the current thread, or of all threads if all_threads is True, into file")),
    ("faulthandler.unregister", Some("unregister(signum): unregister the handler of the signal 'signum' registered by register()")),
    ("gc", Some("This module provides access to the garbage collector for reference cycles.\n\nenable() -- Enable automatic garbage collection.\ndisable() -- Disable automatic garbage collection.\nisenabled() -- Returns true if automatic collection is enabled.\ncollect() -- Do a full collection right now.\nget_count() -- Return the current collection counts.\nget_stats() -- Return list of dictionaries containing per-generation stats.\nset_debug() -- Set debugging flags.\nget_debug() -- Get debugging flags.\nset_threshold() -- Set the collection thresholds.\nget_threshold() -- Return the current the collection thresholds.\nget_objects() -- Return a list of all objects tracked by the collector.\nis_tracked() -- Returns true if a given object is tracked.\nis_finalized() -- Returns true if a given object has been already finalized.\nget_referrers() -- Return the list of objects that refer to an object.\nget_referents() -- Return the list of objects that an object refers to.\nfreeze() -- Freeze all tracked objects and ignore them for future collections.\nunfreeze() -- Unfreeze all objects in the permanent generation.\nget_freeze_count() -- Return the number of objects in the permanent generation.\n")),
    ("gc.collect", Some("Run the garbage collector.\n\nWith no arguments, run a full collection.  The optional argument\nmay be an integer specifying which generation to collect.  A ValueError\nis raised if the generation number is invalid.\n\nThe number of unreachable objects is returned.")),
    ("gc.disable", Some("Disable automatic garbage collection.")),
    ("gc.enable", Some("Enable automatic garbage collection.")),
    ("gc.freeze", Some("Freeze all current tracked objects and ignore them for future collections.\n\nThis can be used before a POSIX fork() call to make the gc copy-on-write friendly.\nNote: collection before a POSIX fork() call may free pages for future allocation\nwhich can cause copy-on-write.")),
    ("gc.get_count", Some("Return a three-tuple of the current collection counts.")),
    ("gc.get_debug", Some("Get the garbage collection debugging flags.")),
    ("gc.get_freeze_count", Some("Return the number of objects in the permanent generation.")),
    ("gc.get_objects", Some("Return a list of objects tracked by the collector (excluding the list returned).\n\n  generation\n    Generation to extract the objects from.\n\nIf generation is not None, return only the objects tracked by the collector\nthat are in that generation.")),
    ("gc.get_referents", Some("get_referents(*objs) -> list\nReturn the list of objects that are directly referred to by objs.")),
    ("gc.get_referrers", Some("get_referrers(*objs) -> list\nReturn the list of objects that directly refer to any of objs.")),
    ("gc.get_stats", Some("Return a list of dictionaries containing per-generation statistics.")),
    ("gc.get_threshold", Some("Return the current collection thresholds.")),
    ("gc.is_finalized", Some("Returns true if the object has been already finalized by the GC.")),
    ("gc.is_tracked", Some("Returns true if the object is tracked by the garbage collector.\n\nSimple atomic objects will return false.")),
    ("gc.isenabled", Some("Returns true if automatic garbage collection is enabled.")),
    ("gc.set_debug", Some("Set the garbage collection debugging flags.\n\n  flags\n    An integer that can have the following bits turned on:\n      DEBUG_STATS - Print statistics during collection.\n      DEBUG_COLLECTABLE - Print collectable objects found.\n      DEBUG_UNCOLLECTABLE - Print unreachable but uncollectable objects\n        found.\n      DEBUG_SAVEALL - Save objects to gc.garbage rather than freeing them.\n      DEBUG_LEAK - Debug leaking programs (everything but STATS).\n\nDebugging information is written to sys.stderr.")),
    ("gc.set_threshold", Some("set_threshold(threshold0, [threshold1, threshold2]) -> None\n\nSets the collection thresholds.  Setting threshold0 to zero disables\ncollection.\n")),
    ("gc.unfreeze", Some("Unfreeze all objects in the permanent generation.\n\nPut all objects in the permanent generation back into oldest generation.")),
    ("itertools", Some("Functional tools for creating and using iterators.\n\nInfinite iterators:\ncount(start=0, step=1) --> start, start+step, start+2*step, ...\ncycle(p) --> p0, p1, ... plast, p0, p1, ...\nrepeat(elem [,n]) --> elem, elem, elem, ... endlessly or up to n times\n\nIterators terminating on the shortest input sequence:\naccumulate(p[, func]) --> p0, p0+p1, p0+p1+p2\nchain(p, q, ...) --> p0, p1, ... plast, q0, q1, ...\nchain.from_iterable([p, q, ...]) --> p0, p1, ... plast, q0, q1, ...\ncompress(data, selectors) --> (d[0] if s[0]), (d[1] if s[1]), ...\ndropwhile(pred, seq) --> seq[n], seq[n+1], starting when pred fails\ngroupby(iterable[, keyfunc]) --> sub-iterators grouped by value of keyfunc(v)\nfilterfalse(pred, seq) --> elements of seq where pred(elem) is False\nislice(seq, [start,] stop [, step]) --> elements from\n       seq[start:stop:step]\npairwise(s) --> (s[0],s[1]), (s[1],s[2]), (s[2], s[3]), ...\nstarmap(fun, seq) --> fun(*seq[0]), fun(*seq[1]), ...\ntee(it, n=2) --> (it1, it2 , ... itn) splits one iterator into n\ntakewhile(pred, seq) --> seq[0], seq[1], until pred fails\nzip_longest(p, q, ...) --> (p[0], q[0]), (p[1], q[1]), ...\n\nCombinatoric generators:\nproduct(p, q, ... [repeat=1]) --> cartesian product\npermutations(p[, r])\ncombinations(p, r)\ncombinations_with_replacement(p, r)\n")),
    ("itertools._grouper.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools._grouper.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools._grouper.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools._tee", Some("Iterator wrapped to make it copyable.")),
    ("itertools._tee.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools._tee.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools._tee.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools._tee_dataobject", Some("teedataobject(iterable, values, next, /)\n--\n\nData container common to multiple tee objects.")),
    ("itertools._tee_dataobject.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools._tee_dataobject.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools._tee_dataobject.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.accumulate", Some("Return series of accumulated sums (or other binary function results).")),
    ("itertools.accumulate.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.accumulate.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.accumulate.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.chain", Some("chain(*iterables) --> chain object\n\nReturn a chain object whose .__next__() method returns elements from the\nfirst iterable until it is exhausted, then elements from the next\niterable, until all of the iterables are exhausted.")),
    ("itertools.chain.__class_getitem__", Some("See PEP 585")),
    ("itertools.chain.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.chain.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.chain.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.chain.from_iterable", Some("Alternative chain() constructor taking a single iterable argument that evaluates lazily.")),
    ("itertools.combinations", Some("Return successive r-length combinations of elements in the iterable.\n\ncombinations(range(4), 3) --> (0,1,2), (0,1,3), (0,2,3), (1,2,3)")),
    ("itertools.combinations.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.combinations.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.combinations.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.combinations_with_replacement", Some("Return successive r-length combinations of elements in the iterable allowing individual elements to have successive repeats.\n\ncombinations_with_replacement('ABC', 2) --> ('A','A'), ('A','B'), ('A','C'), ('B','B'), ('B','C'), ('C','C')")),
    ("itertools.combinations_with_replacement.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.combinations_with_replacement.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.combinations_with_replacement.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.compress", Some("Return data elements corresponding to true selector elements.\n\nForms a shorter iterator from selected data elements using the selectors to\nchoose the data elements.")),
    ("itertools.compress.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.compress.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.compress.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.count", Some("Return a count object whose .__next__() method returns consecutive values.\n\nEquivalent to:\n    def count(firstval=0, step=1):\n        x = firstval\n        while 1:\n            yield x\n            x += step")),
    ("itertools.count.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.count.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.count.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.cycle", Some("Return elements from the iterable until it is exhausted. Then repeat the sequence indefinitely.")),
    ("itertools.cycle.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.cycle.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.cycle.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.dropwhile", Some("Drop items from the iterable while predicate(item) is true.\n\nAfterwards, return every element until the iterable is exhausted.")),
    ("itertools.dropwhile.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.dropwhile.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.dropwhile.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.filterfalse", Some("Return those items of iterable for which function(item) is false.\n\nIf function is None, return the items that are false.")),
    ("itertools.filterfalse.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.filterfalse.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.filterfalse.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.groupby", Some("make an iterator that returns consecutive keys and groups from the iterable\n\n  iterable\n    Elements to divide into groups according to the key function.\n  key\n    A function for computing the group category for each element.\n    If the key function is not specified or is None, the element itself\n    is used for grouping.")),
    ("itertools.groupby.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.groupby.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.groupby.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.islice", Some("islice(iterable, stop) --> islice object\nislice(iterable, start, stop[, step]) --> islice object\n\nReturn an iterator whose next() method returns selected values from an\niterable.  If start is specified, will skip all preceding elements;\notherwise, start defaults to zero.  Step defaults to one.  If\nspecified as another value, step determines how many values are\nskipped between successive calls.  Works like a slice() on a list\nbut returns an iterator.")),
    ("itertools.islice.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.islice.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.islice.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.pairwise", Some("Return an iterator of overlapping pairs taken from the input iterator.\n\n    s -> (s0,s1), (s1,s2), (s2, s3), ...")),
    ("itertools.pairwise.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.pairwise.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.pairwise.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.permutations", Some("Return successive r-length permutations of elements in the iterable.\n\npermutations(range(3), 2) --> (0,1), (0,2), (1,0), (1,2), (2,0), (2,1)")),
    ("itertools.permutations.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.permutations.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.permutations.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.product", Some("product(*iterables, repeat=1) --> product object\n\nCartesian product of input iterables.  Equivalent to nested for-loops.\n\nFor example, product(A, B) returns the same as:  ((x,y) for x in A for y in B).\nThe leftmost iterators are in the outermost for-loop, so the output tuples\ncycle in a manner similar to an odometer (with the rightmost element changing\non every iteration).\n\nTo compute the product of an iterable with itself, specify the number\nof repetitions with the optional repeat keyword argument. For example,\nproduct(A, repeat=4) means the same as product(A, A, A, A).\n\nproduct('ab', range(3)) --> ('a',0) ('a',1) ('a',2) ('b',0) ('b',1) ('b',2)\nproduct((0,1), (0,1), (0,1)) --> (0,0,0) (0,0,1) (0,1,0) (0,1,1) (1,0,0) ...")),
    ("itertools.product.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.product.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.product.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.repeat", Some("repeat(object [,times]) -> create an iterator which returns the object\nfor the specified number of times.  If not specified, returns the object\nendlessly.")),
    ("itertools.repeat.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.repeat.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.repeat.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.starmap", Some("Return an iterator whose values are returned from the function evaluated with an argument tuple taken from the given sequence.")),
    ("itertools.starmap.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.starmap.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.starmap.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.takewhile", Some("Return successive entries from an iterable as long as the predicate evaluates to true for each entry.")),
    ("itertools.takewhile.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.takewhile.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.takewhile.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("itertools.tee", Some("Returns a tuple of n independent iterators.")),
    ("itertools.zip_longest", Some("zip_longest(iter1 [,iter2 [...]], [fillvalue=None]) --> zip_longest object\n\nReturn a zip_longest object whose .__next__() method returns a tuple where\nthe i-th element comes from the i-th iterable argument.  The .__next__()\nmethod continues until the longest iterable in the argument sequence\nis exhausted and then it raises StopIteration.  When the shorter iterables\nare exhausted, the fillvalue is substituted in their place.  The fillvalue\ndefaults to None or can be specified by a keyword argument.\n")),
    ("itertools.zip_longest.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("itertools.zip_longest.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("itertools.zip_longest.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("marshal", Some("This module contains functions that can read and write Python values in\na binary format. The format is specific to Python, but independent of\nmachine architecture issues.\n\nNot all Python object types are supported; in general, only objects\nwhose value is independent from a particular invocation of Python can be\nwritten and read by this module. The following types are supported:\nNone, integers, floating point numbers, strings, bytes, bytearrays,\ntuples, lists, sets, dictionaries, and code objects, where it\nshould be understood that tuples, lists and dictionaries are only\nsupported as long as the values contained therein are themselves\nsupported; and recursive lists and dictionaries should not be written\n(they will cause infinite loops).\n\nVariables:\n\nversion -- indicates the format that the module uses. Version 0 is the\n    historical format, version 1 shares interned strings and version 2\n    uses a binary format for floating point numbers.\n    Version 3 shares common object references (New in version 3.4).\n\nFunctions:\n\ndump() -- write value to a file\nload() -- read value from a file\ndumps() -- marshal value as a bytes object\nloads() -- read value from a bytes-like object")),
    ("marshal.dump", Some("Write the value on the open file.\n\n  value\n    Must be a supported type.\n  file\n    Must be a writeable binary file.\n  version\n    Indicates the data format that dump should use.\n\nIf the value has (or contains an object that has) an unsupported type, a\nValueError exception is raised - but garbage data will also be written\nto the file. The object will not be properly read back by load().")),
    ("marshal.dumps", Some("Return the bytes object that would be written to a file by dump(value, file).\n\n  value\n    Must be a supported type.\n  version\n    Indicates the data format that dumps should use.\n\nRaise a ValueError exception if value has (or contains an object that has) an\nunsupported type.")),
    ("marshal.load", Some("Read one value from the open file and return it.\n\n  file\n    Must be readable binary file.\n\nIf no valid value is read (e.g. because the data has a different Python\nversion's incompatible marshal format), raise EOFError, ValueError or\nTypeError.\n\nNote: If an object containing an unsupported type was marshalled with\ndump(), load() will substitute None for the unmarshallable type.")),
    ("marshal.loads", Some("Convert the bytes-like object to a value.\n\nIf no valid value is found, raise EOFError, ValueError or TypeError.  Extra\nbytes in the input are ignored.")),
    ("posix", Some("This module provides access to operating system functionality that is\nstandardized by the C Standard and the POSIX standard (a thinly\ndisguised Unix interface).  Refer to the library manual and\ncorresponding Unix manual entries for more information on calls.")),
    ("posix.DirEntry.__class_getitem__", Some("See PEP 585")),
    ("posix.DirEntry.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("posix.DirEntry.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("posix.DirEntry.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("posix.WCOREDUMP", Some("Return True if the process returning status was dumped to a core file.")),
    ("posix.WEXITSTATUS", Some("Return the process return code from status.")),
    ("posix.WIFCONTINUED", Some("Return True if a particular process was continued from a job control stop.\n\nReturn True if the process returning status was continued from a\njob control stop.")),
    ("posix.WIFEXITED", Some("Return True if the process returning status exited via the exit() system call.")),
    ("posix.WIFSIGNALED", Some("Return True if the process returning status was terminated by a signal.")),
    ("posix.WIFSTOPPED", Some("Return True if the process returning status was stopped.")),
    ("posix.WSTOPSIG", Some("Return the signal that stopped the process that provided the status value.")),
    ("posix.WTERMSIG", Some("Return the signal that terminated the process that provided the status value.")),
    ("posix._exit", Some("Exit to the system with specified status, without normal exit processing.")),
    ("posix._fcopyfile", Some("Efficiently copy content or metadata of 2 regular file descriptors (macOS).")),
    ("posix._path_normpath", Some("Basic path normalization.")),
    ("posix.abort", Some("Abort the interpreter immediately.\n\nThis function 'dumps core' or otherwise fails in the hardest way possible\non the hosting operating system.  This function never returns.")),
    ("posix.access", Some("Use the real uid/gid to test for access to a path.\n\n  path\n    Path to be tested; can be string, bytes, or a path-like object.\n  mode\n    Operating-system mode bitfield.  Can be F_OK to test existence,\n    or the inclusive-OR of R_OK, W_OK, and X_OK.\n  dir_fd\n    If not None, it should be a file descriptor open to a directory,\n    and path should be relative; path will then be relative to that\n    directory.\n  effective_ids\n    If True, access will use the effective uid/gid instead of\n    the real uid/gid.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    access will examine the symbolic link itself instead of the file\n    the link points to.\n\ndir_fd, effective_ids, and follow_symlinks may not be implemented\n  on your platform.  If they are unavailable, using them will raise a\n  NotImplementedError.\n\nNote that most operations will use the effective uid/gid, therefore this\n  routine can be used in a suid/sgid environment to test if the invoking user\n  has the specified access to the path.")),
    ("posix.chdir", Some("Change the current working directory to the specified path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.")),
    ("posix.chflags", Some("Set file flags.\n\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, chflags will change flags on the symbolic link itself instead of the\n  file the link points to.\nfollow_symlinks may not be implemented on your platform.  If it is\nunavailable, using it will raise a NotImplementedError.")),
    ("posix.chmod", Some("Change the access permissions of a file.\n\n  path\n    Path to be modified.  May always be specified as a str, bytes, or a path-like object.\n    On some platforms, path may also be specified as an open file descriptor.\n    If this functionality is unavailable, using it raises an exception.\n  mode\n    Operating-system mode bitfield.\n  dir_fd\n    If not None, it should be a file descriptor open to a directory,\n    and path should be relative; path will then be relative to that\n    directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    chmod will modify the symbolic link itself instead of the file\n    the link points to.\n\nIt is an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.\ndir_fd and follow_symlinks may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.")),
    ("posix.chown", Some("Change the owner and group id of path to the numeric uid and gid.\\\n\n  path\n    Path to be examined; can be string, bytes, a path-like object, or open-file-descriptor int.\n  dir_fd\n    If not None, it should be a file descriptor open to a directory,\n    and path should be relative; path will then be relative to that\n    directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    stat will examine the symbolic link itself instead of the file\n    the link points to.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, chown will modify the symbolic link itself instead of the file the\n  link points to.\nIt is an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.\ndir_fd and follow_symlinks may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.")),
    ("posix.chroot", Some("Change root directory to path.")),
    ("posix.close", Some("Close a file descriptor.")),
    ("posix.closerange", Some("Closes all file descriptors in [fd_low, fd_high), ignoring errors.")),
    ("posix.confstr", Some("Return a string-valued system configuration variable.")),
    ("posix.cpu_count", Some("Return the number of CPUs in the system; return None if indeterminable.\n\nThis number is not equivalent to the number of CPUs the current process can\nuse.  The number of usable CPUs can be obtained with\n``len(os.sched_getaffinity(0))``")),
    ("posix.ctermid", Some("Return the name of the controlling terminal for this process.")),
    ("posix.device_encoding", Some("Return a string describing the encoding of a terminal's file descriptor.\n\nThe file descriptor must be attached to a terminal.\nIf the device is not a terminal, return None.")),
    ("posix.dup", Some("Return a duplicate of a file descriptor.")),
    ("posix.dup2", Some("Duplicate file descriptor.")),
    ("posix.execv", Some("Execute an executable path with arguments, replacing current process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.")),
    ("posix.execve", Some("Execute an executable path with arguments, replacing current process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.")),
    ("posix.fchdir", Some("Change to the directory of the given file descriptor.\n\nfd must be opened on a directory, not a file.\nEquivalent to os.chdir(fd).")),
    ("posix.fchmod", Some("Change the access permissions of the file given by file descriptor fd.\n\nEquivalent to os.chmod(fd, mode).")),
    ("posix.fchown", Some("Change the owner and group id of the file specified by file descriptor.\n\nEquivalent to os.chown(fd, uid, gid).")),
    ("posix.fork", Some("Fork a child process.\n\nReturn 0 to child process and PID of child to parent process.")),
    ("posix.forkpty", Some("Fork a new process with a new pseudo-terminal as controlling tty.\n\nReturns a tuple of (pid, master_fd).\nLike fork(), return pid of 0 to the child process,\nand pid of child to the parent process.\nTo both, return fd of newly opened pseudo-terminal.")),
    ("posix.fpathconf", Some("Return the configuration limit name for the file descriptor fd.\n\nIf there is no limit, return -1.")),
    ("posix.fspath", Some("Return the file system path representation of the object.\n\nIf the object is str or bytes, then allow it to pass through as-is. If the\nobject defines __fspath__(), then return the result of that method. All other\ntypes raise a TypeError.")),
    ("posix.fstat", Some("Perform a stat system call on the given file descriptor.\n\nLike stat(), but for an open file descriptor.\nEquivalent to os.stat(fd).")),
    ("posix.fstatvfs", Some("Perform an fstatvfs system call on the given fd.\n\nEquivalent to statvfs(fd).")),
    ("posix.fsync", Some("Force write of fd to disk.")),
    ("posix.ftruncate", Some("Truncate a file, specified by file descriptor, to a specific length.")),
    ("posix.get_blocking", Some("Get the blocking mode of the file descriptor.\n\nReturn False if the O_NONBLOCK flag is set, True if the flag is cleared.")),
    ("posix.get_inheritable", Some("Get the close-on-exe flag of the specified file descriptor.")),
    ("posix.get_terminal_size", Some("Return the size of the terminal window as (columns, lines).\n\nThe optional argument fd (default standard output) specifies\nwhich file descriptor should be queried.\n\nIf the file descriptor is not connected to a terminal, an OSError\nis thrown.\n\nThis function will only be defined if an implementation is\navailable for this system.\n\nshutil.get_terminal_size is the high-level function which should\nnormally be used, os.get_terminal_size is the low-level implementation.")),
    ("posix.getcwd", Some("Return a unicode string representing the current working directory.")),
    ("posix.getcwdb", Some("Return a bytes string representing the current working directory.")),
    ("posix.getegid", Some("Return the current process's effective group id.")),
    ("posix.geteuid", Some("Return the current process's effective user id.")),
    ("posix.getgid", Some("Return the current process's group id.")),
    ("posix.getgrouplist", Some("Returns a list of groups to which a user belongs.\n\n  user\n    username to lookup\n  group\n    base group id of the user")),
    ("posix.getgroups", Some("Return list of supplemental group IDs for the process.")),
    ("posix.getloadavg", Some("Return average recent system load information.\n\nReturn the number of processes in the system run queue averaged over\nthe last 1, 5, and 15 minutes as a tuple of three floats.\nRaises OSError if the load average was unobtainable.")),
    ("posix.getlogin", Some("Return the actual login name.")),
    ("posix.getpgid", Some("Call the system call getpgid(), and return the result.")),
    ("posix.getpgrp", Some("Return the current process group id.")),
    ("posix.getpid", Some("Return the current process id.")),
    ("posix.getppid", Some("Return the parent's process id.\n\nIf the parent process has already exited, Windows machines will still\nreturn its id; others systems will return the id of the 'init' process (1).")),
    ("posix.getpriority", Some("Return program scheduling priority.")),
    ("posix.getsid", Some("Call the system call getsid(pid) and return the result.")),
    ("posix.getuid", Some("Return the current process's user id.")),
    ("posix.initgroups", Some("Initialize the group access list.\n\nCall the system initgroups() to initialize the group access list with all of\nthe groups of which the specified username is a member, plus the specified\ngroup id.")),
    ("posix.isatty", Some("Return True if the fd is connected to a terminal.\n\nReturn True if the file descriptor is an open file descriptor\nconnected to the slave end of a terminal.")),
    ("posix.kill", Some("Kill a process with a signal.")),
    ("posix.killpg", Some("Kill a process group with a signal.")),
    ("posix.lchflags", Some("Set file flags.\n\nThis function will not follow symbolic links.\nEquivalent to chflags(path, flags, follow_symlinks=False).")),
    ("posix.lchmod", Some("Change the access permissions of a file, without following symbolic links.\n\nIf path is a symlink, this affects the link itself rather than the target.\nEquivalent to chmod(path, mode, follow_symlinks=False).\"")),
    ("posix.lchown", Some("Change the owner and group id of path to the numeric uid and gid.\n\nThis function will not follow symbolic links.\nEquivalent to os.chown(path, uid, gid, follow_symlinks=False).")),
    ("posix.link", Some("Create a hard link to a file.\n\nIf either src_dir_fd or dst_dir_fd is not None, it should be a file\n  descriptor open to a directory, and the respective path string (src or dst)\n  should be relative; the path will then be relative to that directory.\nIf follow_symlinks is False, and the last element of src is a symbolic\n  link, link will create a link to the symbolic link itself instead of the\n  file the link points to.\nsrc_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your\n  platform.  If they are unavailable, using them will raise a\n  NotImplementedError.")),
    ("posix.listdir", Some("Return a list containing the names of the files in the directory.\n\npath can be specified as either str, bytes, or a path-like object.  If path is bytes,\n  the filenames returned will also be bytes; in all other circumstances\n  the filenames returned will be str.\nIf path is None, uses the path='.'.\nOn some platforms, path may also be specified as an open file descriptor;\\\n  the file descriptor must refer to a directory.\n  If this functionality is unavailable, using it raises NotImplementedError.\n\nThe list is in arbitrary order.  It does not include the special\nentries '.' and '..' even if they are present in the directory.")),
    ("posix.lockf", Some("Apply, test or remove a POSIX lock on an open file descriptor.\n\n  fd\n    An open file descriptor.\n  command\n    One of F_LOCK, F_TLOCK, F_ULOCK or F_TEST.\n  length\n    The number of bytes to lock, starting at the current position.")),
    ("posix.login_tty", Some("Prepare the tty of which fd is a file descriptor for a new login session.\n\nMake the calling process a session leader; make the tty the\ncontrolling tty, the stdin, the stdout, and the stderr of the\ncalling process; close fd.")),
    ("posix.lseek", Some("Set the position of a file descriptor.  Return the new position.\n\n  fd\n    An open file descriptor, as returned by os.open().\n  position\n    Position, interpreted relative to 'whence'.\n  whence\n    The relative position to seek from. Valid values are:\n    - SEEK_SET: seek from the start of the file.\n    - SEEK_CUR: seek from the current file position.\n    - SEEK_END: seek from the end of the file.\n\nThe return value is the number of bytes relative to the beginning of the file.")),
    ("posix.lstat", Some("Perform a stat system call on the given path, without following symbolic links.\n\nLike stat(), but do not follow symbolic links.\nEquivalent to stat(path, follow_symlinks=False).")),
    ("posix.major", Some("Extracts a device major number from a raw device number.")),
    ("posix.makedev", Some("Composes a raw device number from the major and minor device numbers.")),
    ("posix.minor", Some("Extracts a device minor number from a raw device number.")),
    ("posix.mkdir", Some("Create a directory.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.\n\nThe mode argument is ignored on Windows. Where it is used, the current umask\nvalue is first masked out.")),
    ("posix.mkfifo", Some("Create a \"fifo\" (a POSIX named pipe).\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.mknod", Some("Create a node in the file system.\n\nCreate a node in the file system (file, device special file or named pipe)\nat path.  mode specifies both the permissions to use and the\ntype of node to be created, being combined (bitwise OR) with one of\nS_IFREG, S_IFCHR, S_IFBLK, and S_IFIFO.  If S_IFCHR or S_IFBLK is set on mode,\ndevice defines the newly created device special file (probably using\nos.makedev()).  Otherwise device is ignored.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.nice", Some("Add increment to the priority of process and return the new priority.")),
    ("posix.open", Some("Open a file for low level IO.  Returns a file descriptor (integer).\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.openpty", Some("Open a pseudo-terminal.\n\nReturn a tuple of (master_fd, slave_fd) containing open file descriptors\nfor both the master and slave ends.")),
    ("posix.pathconf", Some("Return the configuration limit name for the file or directory path.\n\nIf there is no limit, return -1.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.")),
    ("posix.pipe", Some("Create a pipe.\n\nReturns a tuple of two file descriptors:\n  (read_fd, write_fd)")),
    ("posix.posix_spawn", Some("Execute the program specified by path in a new process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.\n  file_actions\n    A sequence of file action tuples.\n  setpgroup\n    The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\n  resetids\n    If the value is `true` the POSIX_SPAWN_RESETIDS will be activated.\n  setsid\n    If the value is `true` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\n  setsigmask\n    The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\n  setsigdef\n    The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\n  scheduler\n    A tuple with the scheduler policy (optional) and parameters.")),
    ("posix.posix_spawnp", Some("Execute the program specified by path in a new process.\n\n  path\n    Path of executable file.\n  argv\n    Tuple or list of strings.\n  env\n    Dictionary of strings mapping to strings.\n  file_actions\n    A sequence of file action tuples.\n  setpgroup\n    The pgroup to use with the POSIX_SPAWN_SETPGROUP flag.\n  resetids\n    If the value is `True` the POSIX_SPAWN_RESETIDS will be activated.\n  setsid\n    If the value is `True` the POSIX_SPAWN_SETSID or POSIX_SPAWN_SETSID_NP will be activated.\n  setsigmask\n    The sigmask to use with the POSIX_SPAWN_SETSIGMASK flag.\n  setsigdef\n    The sigmask to use with the POSIX_SPAWN_SETSIGDEF flag.\n  scheduler\n    A tuple with the scheduler policy (optional) and parameters.")),
    ("posix.pread", Some("Read a number of bytes from a file descriptor starting at a particular offset.\n\nRead length bytes from file descriptor fd, starting at offset bytes from\nthe beginning of the file.  The file offset remains unchanged.")),
    ("posix.preadv", Some("Reads from a file descriptor into a number of mutable bytes-like objects.\n\nCombines the functionality of readv() and pread(). As readv(), it will\ntransfer data into each buffer until it is full and then move on to the next\nbuffer in the sequence to hold the rest of the data. Its fourth argument,\nspecifies the file offset at which the input operation is to be performed. It\nwill return the total number of bytes read (which can be less than the total\ncapacity of all the objects).\n\nThe flags argument contains a bitwise OR of zero or more of the following flags:\n\n- RWF_HIPRI\n- RWF_NOWAIT\n\nUsing non-zero flags requires Linux 4.6 or newer.")),
    ("posix.putenv", Some("Change or add an environment variable.")),
    ("posix.pwrite", Some("Write bytes to a file descriptor starting at a particular offset.\n\nWrite buffer to fd, starting at offset bytes from the beginning of\nthe file.  Returns the number of bytes writte.  Does not change the\ncurrent file offset.")),
    ("posix.pwritev", Some("Writes the contents of bytes-like objects to a file descriptor at a given offset.\n\nCombines the functionality of writev() and pwrite(). All buffers must be a sequence\nof bytes-like objects. Buffers are processed in array order. Entire contents of first\nbuffer is written before proceeding to second, and so on. The operating system may\nset a limit (sysconf() value SC_IOV_MAX) on the number of buffers that can be used.\nThis function writes the contents of each object to the file descriptor and returns\nthe total number of bytes written.\n\nThe flags argument contains a bitwise OR of zero or more of the following flags:\n\n- RWF_DSYNC\n- RWF_SYNC\n- RWF_APPEND\n\nUsing non-zero flags requires Linux 4.7 or newer.")),
    ("posix.read", Some("Read from a file descriptor.  Returns a bytes object.")),
    ("posix.readlink", Some("Return a string representing the path to which the symbolic link points.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\nand path should be relative; path will then be relative to that directory.\n\ndir_fd may not be implemented on your platform.  If it is unavailable,\nusing it will raise a NotImplementedError.")),
    ("posix.readv", Some("Read from a file descriptor fd into an iterable of buffers.\n\nThe buffers should be mutable buffers accepting bytes.\nreadv will transfer data into each buffer until it is full\nand then move on to the next buffer in the sequence to hold\nthe rest of the data.\n\nreadv returns the total number of bytes read,\nwhich may be less than the total capacity of all the buffers.")),
    ("posix.register_at_fork", Some("Register callables to be called when forking a new process.\n\n  before\n    A callable to be called in the parent before the fork() syscall.\n  after_in_child\n    A callable to be called in the child after fork().\n  after_in_parent\n    A callable to be called in the parent after fork().\n\n'before' callbacks are called in reverse order.\n'after_in_child' and 'after_in_parent' callbacks are called in order.")),
    ("posix.remove", Some("Remove a file (same as unlink()).\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.rename", Some("Rename a file or directory.\n\nIf either src_dir_fd or dst_dir_fd is not None, it should be a file\n  descriptor open to a directory, and the respective path string (src or dst)\n  should be relative; the path will then be relative to that directory.\nsrc_dir_fd and dst_dir_fd, may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.")),
    ("posix.replace", Some("Rename a file or directory, overwriting the destination.\n\nIf either src_dir_fd or dst_dir_fd is not None, it should be a file\n  descriptor open to a directory, and the respective path string (src or dst)\n  should be relative; the path will then be relative to that directory.\nsrc_dir_fd and dst_dir_fd, may not be implemented on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.")),
    ("posix.rmdir", Some("Remove a directory.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.scandir", Some("Return an iterator of DirEntry objects for given path.\n\npath can be specified as either str, bytes, or a path-like object.  If path\nis bytes, the names of yielded DirEntry objects will also be bytes; in\nall other circumstances they will be str.\n\nIf path is None, uses the path='.'.")),
    ("posix.sched_get_priority_max", Some("Get the maximum scheduling priority for policy.")),
    ("posix.sched_get_priority_min", Some("Get the minimum scheduling priority for policy.")),
    ("posix.sched_yield", Some("Voluntarily relinquish the CPU.")),
    ("posix.sendfile", Some("Copy count bytes from file descriptor in_fd to file descriptor out_fd.")),
    ("posix.set_blocking", Some("Set the blocking mode of the specified file descriptor.\n\nSet the O_NONBLOCK flag if blocking is False,\nclear the O_NONBLOCK flag otherwise.")),
    ("posix.set_inheritable", Some("Set the inheritable flag of the specified file descriptor.")),
    ("posix.setegid", Some("Set the current process's effective group id.")),
    ("posix.seteuid", Some("Set the current process's effective user id.")),
    ("posix.setgid", Some("Set the current process's group id.")),
    ("posix.setgroups", Some("Set the groups of the current process to list.")),
    ("posix.setpgid", Some("Call the system call setpgid(pid, pgrp).")),
    ("posix.setpgrp", Some("Make the current process the leader of its process group.")),
    ("posix.setpriority", Some("Set program scheduling priority.")),
    ("posix.setregid", Some("Set the current process's real and effective group ids.")),
    ("posix.setreuid", Some("Set the current process's real and effective user ids.")),
    ("posix.setsid", Some("Call the system call setsid().")),
    ("posix.setuid", Some("Set the current process's user id.")),
    ("posix.stat", Some("Perform a stat system call on the given path.\n\n  path\n    Path to be examined; can be string, bytes, a path-like object or\n    open-file-descriptor int.\n  dir_fd\n    If not None, it should be a file descriptor open to a directory,\n    and path should be a relative string; path will then be relative to\n    that directory.\n  follow_symlinks\n    If False, and the last element of the path is a symbolic link,\n    stat will examine the symbolic link itself instead of the file\n    the link points to.\n\ndir_fd and follow_symlinks may not be implemented\n  on your platform.  If they are unavailable, using them will raise a\n  NotImplementedError.\n\nIt's an error to use dir_fd or follow_symlinks when specifying path as\n  an open file descriptor.")),
    ("posix.statvfs", Some("Perform a statvfs system call on the given path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.")),
    ("posix.strerror", Some("Translate an error code to a message string.")),
    ("posix.symlink", Some("Create a symbolic link pointing to src named dst.\n\ntarget_is_directory is required on Windows if the target is to be\n  interpreted as a directory.  (On Windows, symlink requires\n  Windows 6.0 or greater, and raises a NotImplementedError otherwise.)\n  target_is_directory is ignored on non-Windows platforms.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.sync", Some("Force write of everything to disk.")),
    ("posix.sysconf", Some("Return an integer-valued system configuration variable.")),
    ("posix.system", Some("Execute the command in a subshell.")),
    ("posix.tcgetpgrp", Some("Return the process group associated with the terminal specified by fd.")),
    ("posix.tcsetpgrp", Some("Set the process group associated with the terminal specified by fd.")),
    ("posix.times", Some("Return a collection containing process timing information.\n\nThe object returned behaves like a named tuple with these fields:\n  (utime, stime, cutime, cstime, elapsed_time)\nAll fields are floating point numbers.")),
    ("posix.times_result", Some("times_result: Result from os.times().\n\nThis object may be accessed either as a tuple of\n  (user, system, children_user, children_system, elapsed),\nor via the attributes user, system, children_user, children_system,\nand elapsed.\n\nSee os.times for more information.")),
    ("posix.times_result.__class_getitem__", Some("See PEP 585")),
    ("posix.times_result.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("posix.times_result.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("posix.times_result.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("posix.truncate", Some("Truncate a file, specified by path, to a specific length.\n\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.")),
    ("posix.ttyname", Some("Return the name of the terminal device connected to 'fd'.\n\n  fd\n    Integer file descriptor handle.")),
    ("posix.umask", Some("Set the current numeric umask and return the previous umask.")),
    ("posix.uname", Some("Return an object identifying the current operating system.\n\nThe object behaves like a named tuple with the following fields:\n  (sysname, nodename, release, version, machine)")),
    ("posix.uname_result", Some("uname_result: Result from os.uname().\n\nThis object may be accessed either as a tuple of\n  (sysname, nodename, release, version, machine),\nor via the attributes sysname, nodename, release, version, and machine.\n\nSee os.uname for more information.")),
    ("posix.uname_result.__class_getitem__", Some("See PEP 585")),
    ("posix.uname_result.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("posix.uname_result.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("posix.uname_result.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("posix.unlink", Some("Remove a file (same as remove()).\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\ndir_fd may not be implemented on your platform.\n  If it is unavailable, using it will raise a NotImplementedError.")),
    ("posix.unsetenv", Some("Delete an environment variable.")),
    ("posix.urandom", Some("Return a bytes object containing random bytes suitable for cryptographic use.")),
    ("posix.utime", Some("Set the access and modified time of path.\n\npath may always be specified as a string.\nOn some platforms, path may also be specified as an open file descriptor.\n  If this functionality is unavailable, using it raises an exception.\n\nIf times is not None, it must be a tuple (atime, mtime);\n    atime and mtime should be expressed as float seconds since the epoch.\nIf ns is specified, it must be a tuple (atime_ns, mtime_ns);\n    atime_ns and mtime_ns should be expressed as integer nanoseconds\n    since the epoch.\nIf times is None and ns is unspecified, utime uses the current time.\nSpecifying tuples for both times and ns is an error.\n\nIf dir_fd is not None, it should be a file descriptor open to a directory,\n  and path should be relative; path will then be relative to that directory.\nIf follow_symlinks is False, and the last element of the path is a symbolic\n  link, utime will modify the symbolic link itself instead of the file the\n  link points to.\nIt is an error to use dir_fd or follow_symlinks when specifying path\n  as an open file descriptor.\ndir_fd and follow_symlinks may not be available on your platform.\n  If they are unavailable, using them will raise a NotImplementedError.")),
    ("posix.wait", Some("Wait for completion of a child process.\n\nReturns a tuple of information about the child process:\n    (pid, status)")),
    ("posix.wait3", Some("Wait for completion of a child process.\n\nReturns a tuple of information about the child process:\n  (pid, status, rusage)")),
    ("posix.wait4", Some("Wait for completion of a specific child process.\n\nReturns a tuple of information about the child process:\n  (pid, status, rusage)")),
    ("posix.waitpid", Some("Wait for completion of a given child process.\n\nReturns a tuple of information regarding the child process:\n    (pid, status)\n\nThe options argument is ignored on Windows.")),
    ("posix.waitstatus_to_exitcode", Some("Convert a wait status to an exit code.\n\nOn Unix:\n\n* If WIFEXITED(status) is true, return WEXITSTATUS(status).\n* If WIFSIGNALED(status) is true, return -WTERMSIG(status).\n* Otherwise, raise a ValueError.\n\nOn Windows, return status shifted right by 8 bits.\n\nOn Unix, if the process is being traced or if waitpid() was called with\nWUNTRACED option, the caller must first check if WIFSTOPPED(status) is true.\nThis function must not be called if WIFSTOPPED(status) is true.")),
    ("posix.write", Some("Write a bytes object to a file descriptor.")),
    ("posix.writev", Some("Iterate over buffers, and write the contents of each to a file descriptor.\n\nReturns the total number of bytes written.\nbuffers must be a sequence of bytes-like objects.")),
    ("pwd", Some("This module provides access to the Unix password database.\nIt is available on all Unix versions.\n\nPassword database entries are reported as 7-tuples containing the following\nitems from the password database (see `<pwd.h>'), in order:\npw_name, pw_passwd, pw_uid, pw_gid, pw_gecos, pw_dir, pw_shell.\nThe uid and gid items are integers, all others are strings. An\nexception is raised if the entry asked for cannot be found.")),
    ("pwd.getpwall", Some("Return a list of all available password database entries, in arbitrary order.\n\nSee help(pwd) for more on password database entries.")),
    ("pwd.getpwnam", Some("Return the password database entry for the given user name.\n\nSee `help(pwd)` for more on password database entries.")),
    ("pwd.getpwuid", Some("Return the password database entry for the given numeric user ID.\n\nSee `help(pwd)` for more on password database entries.")),
    ("pwd.struct_passwd", Some("pwd.struct_passwd: Results from getpw*() routines.\n\nThis object may be accessed either as a tuple of\n  (pw_name,pw_passwd,pw_uid,pw_gid,pw_gecos,pw_dir,pw_shell)\nor via the object attributes as named in the above tuple.")),
    ("pwd.struct_passwd.__class_getitem__", Some("See PEP 585")),
    ("pwd.struct_passwd.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("pwd.struct_passwd.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("pwd.struct_passwd.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("sys", Some("This module provides access to some objects used or maintained by the\ninterpreter and to functions that interact strongly with the interpreter.\n\nDynamic objects:\n\nargv -- command line arguments; argv[0] is the script pathname if known\npath -- module search path; path[0] is the script directory, else ''\nmodules -- dictionary of loaded modules\n\ndisplayhook -- called to show results in an interactive session\nexcepthook -- called to handle any uncaught exception other than SystemExit\n  To customize printing in an interactive session or to install a custom\n  top-level exception handler, assign other functions to replace these.\n\nstdin -- standard input file object; used by input()\nstdout -- standard output file object; used by print()\nstderr -- standard error object; used for error messages\n  By assigning other file objects (or objects that behave like files)\n  to these, it is possible to redirect all of the interpreter's I/O.\n\nlast_type -- type of last uncaught exception\nlast_value -- value of last uncaught exception\nlast_traceback -- traceback of last uncaught exception\n  These three are only available in an interactive session after a\n  traceback has been printed.\n\nStatic objects:\n\nbuiltin_module_names -- tuple of module names built into this interpreter\ncopyright -- copyright notice pertaining to this interpreter\nexec_prefix -- prefix used to find the machine-specific Python library\nexecutable -- absolute path of the executable binary of the Python interpreter\nfloat_info -- a named tuple with information about the float implementation.\nfloat_repr_style -- string indicating the style of repr() output for floats\nhash_info -- a named tuple with information about the hash algorithm.\nhexversion -- version information encoded as a single integer\nimplementation -- Python implementation information.\nint_info -- a named tuple with information about the int implementation.\nmaxsize -- the largest supported length of containers.\nmaxunicode -- the value of the largest Unicode code point\nplatform -- platform identifier\nprefix -- prefix used to find the Python library\nthread_info -- a named tuple with information about the thread implementation.\nversion -- the version of this interpreter as a string\nversion_info -- version information as a named tuple\n__stdin__ -- the original stdin; don't touch!\n__stdout__ -- the original stdout; don't touch!\n__stderr__ -- the original stderr; don't touch!\n__displayhook__ -- the original displayhook; don't touch!\n__excepthook__ -- the original excepthook; don't touch!\n\nFunctions:\n\ndisplayhook() -- print an object to the screen, and save it in builtins._\nexcepthook() -- print an exception and its traceback to sys.stderr\nexception() -- return the current thread's active exception\nexc_info() -- return information about the current thread's active exception\nexit() -- exit the interpreter by raising SystemExit\ngetdlopenflags() -- returns flags to be used for dlopen() calls\ngetprofile() -- get the global profiling function\ngetrefcount() -- return the reference count for an object (plus one :-)\ngetrecursionlimit() -- return the max recursion depth for the interpreter\ngetsizeof() -- return the size of an object in bytes\ngettrace() -- get the global debug tracing function\nsetdlopenflags() -- set the flags to be used for dlopen() calls\nsetprofile() -- set the global profiling function\nsetrecursionlimit() -- set the max recursion depth for the interpreter\nsettrace() -- set the global debug tracing function\n")),
    ("sys.__breakpointhook__", Some("breakpointhook(*args, **kws)\n\nThis hook function is called by built-in breakpoint().\n")),
    ("sys.__displayhook__", Some("Print an object to sys.stdout and also save it in builtins._")),
    ("sys.__excepthook__", Some("Handle an exception by displaying it with a traceback on sys.stderr.")),
    ("sys.__unraisablehook__", Some("Handle an unraisable exception.\n\nThe unraisable argument has the following attributes:\n\n* exc_type: Exception type.\n* exc_value: Exception value, can be None.\n* exc_traceback: Exception traceback, can be None.\n* err_msg: Error message, can be None.\n* object: Object causing the exception, can be None.")),
    ("sys._clear_type_cache", Some("Clear the internal type lookup cache.")),
    ("sys._current_exceptions", Some("Return a dict mapping each thread's identifier to its current raised exception.\n\nThis function should be used for specialized purposes only.")),
    ("sys._current_frames", Some("Return a dict mapping each thread's thread id to its current stack frame.\n\nThis function should be used for specialized purposes only.")),
    ("sys._debugmallocstats", Some("Print summary info to stderr about the state of pymalloc's structures.\n\nIn Py_DEBUG mode, also perform some expensive internal consistency\nchecks.")),
    ("sys._getframe", Some("Return a frame object from the call stack.\n\nIf optional integer depth is given, return the frame object that many\ncalls below the top of the stack.  If that is deeper than the call\nstack, ValueError is raised.  The default for depth is zero, returning\nthe frame at the top of the call stack.\n\nThis function should be used for internal and specialized purposes\nonly.")),
    ("sys._getquickenedcount", None),
    ("sys.addaudithook", Some("Adds a new audit hook callback.")),
    ("sys.audit", Some("audit(event, *args)\n\nPasses the event to any audit hooks that are attached.")),
    ("sys.breakpointhook", Some("breakpointhook(*args, **kws)\n\nThis hook function is called by built-in breakpoint().\n")),
    ("sys.call_tracing", Some("Call func(*args), while tracing is enabled.\n\nThe tracing state is saved, and restored afterwards.  This is intended\nto be called from a debugger from a checkpoint, to recursively debug\nsome other code.")),
    ("sys.displayhook", Some("Print an object to sys.stdout and also save it in builtins._")),
    ("sys.exc_info", Some("Return current exception information: (type, value, traceback).\n\nReturn information about the most recent exception caught by an except\nclause in the current stack frame or in an older stack frame.")),
    ("sys.excepthook", Some("Handle an exception by displaying it with a traceback on sys.stderr.")),
    ("sys.exception", Some("Return the current exception.\n\nReturn the most recent exception caught by an except clause\nin the current stack frame or in an older stack frame, or None\nif no such exception exists.")),
    ("sys.exit", Some("Exit the interpreter by raising SystemExit(status).\n\nIf the status is omitted or None, it defaults to zero (i.e., success).\nIf the status is an integer, it will be used as the system exit status.\nIf it is another kind of object, it will be printed and the system\nexit status will be one (i.e., failure).")),
    ("sys.get_asyncgen_hooks", Some("Return the installed asynchronous generators hooks.\n\nThis returns a namedtuple of the form (firstiter, finalizer).")),
    ("sys.get_coroutine_origin_tracking_depth", Some("Check status of origin tracking for coroutine objects in this thread.")),
    ("sys.get_int_max_str_digits", Some("Return the maximum string digits limit for non-binary int<->str conversions.")),
    ("sys.getallocatedblocks", Some("Return the number of memory blocks currently allocated.")),
    ("sys.getdefaultencoding", Some("Return the current default encoding used by the Unicode implementation.")),
    ("sys.getdlopenflags", Some("Return the current value of the flags that are used for dlopen calls.\n\nThe flag constants are defined in the os module.")),
    ("sys.getfilesystemencodeerrors", Some("Return the error mode used Unicode to OS filename conversion.")),
    ("sys.getfilesystemencoding", Some("Return the encoding used to convert Unicode filenames to OS filenames.")),
    ("sys.getprofile", Some("Return the profiling function set with sys.setprofile.\n\nSee the profiler chapter in the library manual.")),
    ("sys.getrecursionlimit", Some("Return the current value of the recursion limit.\n\nThe recursion limit is the maximum depth of the Python interpreter\nstack.  This limit prevents infinite recursion from causing an overflow\nof the C stack and crashing Python.")),
    ("sys.getrefcount", Some("Return the reference count of object.\n\nThe count returned is generally one higher than you might expect,\nbecause it includes the (temporary) reference as an argument to\ngetrefcount().")),
    ("sys.getsizeof", Some("getsizeof(object [, default]) -> int\n\nReturn the size of object in bytes.")),
    ("sys.getswitchinterval", Some("Return the current thread switch interval; see sys.setswitchinterval().")),
    ("sys.gettrace", Some("Return the global debug tracing function set with sys.settrace.\n\nSee the debugger chapter in the library manual.")),
    ("sys.intern", Some("``Intern'' the given string.\n\nThis enters the string in the (global) table of interned strings whose\npurpose is to speed up dictionary lookups. Return the string itself or\nthe previously interned string object with the same value.")),
    ("sys.is_finalizing", Some("Return True if Python is exiting.")),
    ("sys.set_asyncgen_hooks", Some("set_asyncgen_hooks(* [, firstiter] [, finalizer])\n\nSet a finalizer for async generators objects.")),
    ("sys.set_coroutine_origin_tracking_depth", Some("Enable or disable origin tracking for coroutine objects in this thread.\n\nCoroutine objects will track 'depth' frames of traceback information\nabout where they came from, available in their cr_origin attribute.\n\nSet a depth of 0 to disable.")),
    ("sys.set_int_max_str_digits", Some("Set the maximum string digits limit for non-binary int<->str conversions.")),
    ("sys.setdlopenflags", Some("Set the flags used by the interpreter for dlopen calls.\n\nThis is used, for example, when the interpreter loads extension\nmodules. Among other things, this will enable a lazy resolving of\nsymbols when importing a module, if called as sys.setdlopenflags(0).\nTo share symbols across extension modules, call as\nsys.setdlopenflags(os.RTLD_GLOBAL).  Symbolic names for the flag\nmodules can be found in the os module (RTLD_xxx constants, e.g.\nos.RTLD_LAZY).")),
    ("sys.setprofile", Some("setprofile(function)\n\nSet the profiling function.  It will be called on each function call\nand return.  See the profiler chapter in the library manual.")),
    ("sys.setrecursionlimit", Some("Set the maximum depth of the Python interpreter stack to n.\n\nThis limit prevents infinite recursion from causing an overflow of the C\nstack and crashing Python.  The highest possible limit is platform-\ndependent.")),
    ("sys.setswitchinterval", Some("Set the ideal thread switching delay inside the Python interpreter.\n\nThe actual frequency of switching threads can be lower if the\ninterpreter executes long sequences of uninterruptible code\n(this is implementation-specific and workload-dependent).\n\nThe parameter must represent the desired switching delay in seconds\nA typical value is 0.005 (5 milliseconds).")),
    ("sys.settrace", Some("settrace(function)\n\nSet the global debug tracing function.  It will be called on each\nfunction call.  See the debugger chapter in the library manual.")),
    ("sys.unraisablehook", Some("Handle an unraisable exception.\n\nThe unraisable argument has the following attributes:\n\n* exc_type: Exception type.\n* exc_value: Exception value, can be None.\n* exc_traceback: Exception traceback, can be None.\n* err_msg: Error message, can be None.\n* object: Object causing the exception, can be None.")),
    ("time", Some("This module provides various functions to manipulate time values.\n\nThere are two standard representations of time.  One is the number\nof seconds since the Epoch, in UTC (a.k.a. GMT).  It may be an integer\nor a floating point number (to represent fractions of seconds).\nThe Epoch is system-defined; on Unix, it is generally January 1st, 1970.\nThe actual value can be retrieved by calling gmtime(0).\n\nThe other representation is a tuple of 9 integers giving local time.\nThe tuple items are:\n  year (including century, e.g. 1998)\n  month (1-12)\n  day (1-31)\n  hours (0-23)\n  minutes (0-59)\n  seconds (0-59)\n  weekday (0-6, Monday is 0)\n  Julian day (day in the year, 1-366)\n  DST (Daylight Savings Time) flag (-1, 0 or 1)\nIf the DST flag is 0, the time is given in the regular time zone;\nif it is 1, the time is given in the DST time zone;\nif it is -1, mktime() should guess based on the date and time.\n")),
    ("time.asctime", Some("asctime([tuple]) -> string\n\nConvert a time tuple to a string, e.g. 'Sat Jun 06 16:26:11 1998'.\nWhen the time tuple is not present, current time as returned by localtime()\nis used.")),
    ("time.clock_getres", Some("clock_getres(clk_id) -> floating point number\n\nReturn the resolution (precision) of the specified clock clk_id.")),
    ("time.clock_gettime", Some("clock_gettime(clk_id) -> float\n\nReturn the time of the specified clock clk_id.")),
    ("time.clock_gettime_ns", Some("clock_gettime_ns(clk_id) -> int\n\nReturn the time of the specified clock clk_id as nanoseconds.")),
    ("time.clock_settime", Some("clock_settime(clk_id, time)\n\nSet the time of the specified clock clk_id.")),
    ("time.clock_settime_ns", Some("clock_settime_ns(clk_id, time)\n\nSet the time of the specified clock clk_id with nanoseconds.")),
    ("time.ctime", Some("ctime(seconds) -> string\n\nConvert a time in seconds since the Epoch to a string in local time.\nThis is equivalent to asctime(localtime(seconds)). When the time tuple is\nnot present, current time as returned by localtime() is used.")),
    ("time.get_clock_info", Some("get_clock_info(name: str) -> dict\n\nGet information of the specified clock.")),
    ("time.gmtime", Some("gmtime([seconds]) -> (tm_year, tm_mon, tm_mday, tm_hour, tm_min,\n                       tm_sec, tm_wday, tm_yday, tm_isdst)\n\nConvert seconds since the Epoch to a time tuple expressing UTC (a.k.a.\nGMT).  When 'seconds' is not passed in, convert the current time instead.\n\nIf the platform supports the tm_gmtoff and tm_zone, they are available as\nattributes only.")),
    ("time.localtime", Some("localtime([seconds]) -> (tm_year,tm_mon,tm_mday,tm_hour,tm_min,\n                          tm_sec,tm_wday,tm_yday,tm_isdst)\n\nConvert seconds since the Epoch to a time tuple expressing local time.\nWhen 'seconds' is not passed in, convert the current time instead.")),
    ("time.mktime", Some("mktime(tuple) -> floating point number\n\nConvert a time tuple in local time to seconds since the Epoch.\nNote that mktime(gmtime(0)) will not generally return zero for most\ntime zones; instead the returned value will either be equal to that\nof the timezone or altzone attributes on the time module.")),
    ("time.monotonic", Some("monotonic() -> float\n\nMonotonic clock, cannot go backward.")),
    ("time.monotonic_ns", Some("monotonic_ns() -> int\n\nMonotonic clock, cannot go backward, as nanoseconds.")),
    ("time.perf_counter", Some("perf_counter() -> float\n\nPerformance counter for benchmarking.")),
    ("time.perf_counter_ns", Some("perf_counter_ns() -> int\n\nPerformance counter for benchmarking as nanoseconds.")),
    ("time.process_time", Some("process_time() -> float\n\nProcess time for profiling: sum of the kernel and user-space CPU time.")),
    ("time.process_time_ns", Some("process_time() -> int\n\nProcess time for profiling as nanoseconds:\nsum of the kernel and user-space CPU time.")),
    ("time.sleep", Some("sleep(seconds)\n\nDelay execution for a given number of seconds.  The argument may be\na floating point number for subsecond precision.")),
    ("time.strftime", Some("strftime(format[, tuple]) -> string\n\nConvert a time tuple to a string according to a format specification.\nSee the library reference manual for formatting codes. When the time tuple\nis not present, current time as returned by localtime() is used.\n\nCommonly used format codes:\n\n%Y  Year with century as a decimal number.\n%m  Month as a decimal number [01,12].\n%d  Day of the month as a decimal number [01,31].\n%H  Hour (24-hour clock) as a decimal number [00,23].\n%M  Minute as a decimal number [00,59].\n%S  Second as a decimal number [00,61].\n%z  Time zone offset from UTC.\n%a  Locale's abbreviated weekday name.\n%A  Locale's full weekday name.\n%b  Locale's abbreviated month name.\n%B  Locale's full month name.\n%c  Locale's appropriate date and time representation.\n%I  Hour (12-hour clock) as a decimal number [01,12].\n%p  Locale's equivalent of either AM or PM.\n\nOther codes may be available on your platform.  See documentation for\nthe C library strftime function.\n")),
    ("time.strptime", Some("strptime(string, format) -> struct_time\n\nParse a string to a time tuple according to a format specification.\nSee the library reference manual for formatting codes (same as\nstrftime()).\n\nCommonly used format codes:\n\n%Y  Year with century as a decimal number.\n%m  Month as a decimal number [01,12].\n%d  Day of the month as a decimal number [01,31].\n%H  Hour (24-hour clock) as a decimal number [00,23].\n%M  Minute as a decimal number [00,59].\n%S  Second as a decimal number [00,61].\n%z  Time zone offset from UTC.\n%a  Locale's abbreviated weekday name.\n%A  Locale's full weekday name.\n%b  Locale's abbreviated month name.\n%B  Locale's full month name.\n%c  Locale's appropriate date and time representation.\n%I  Hour (12-hour clock) as a decimal number [01,12].\n%p  Locale's equivalent of either AM or PM.\n\nOther codes may be available on your platform.  See documentation for\nthe C library strftime function.\n")),
    ("time.struct_time", Some("The time value as returned by gmtime(), localtime(), and strptime(), and\n accepted by asctime(), mktime() and strftime().  May be considered as a\n sequence of 9 integers.\n\n Note that several fields' values are not the same as those defined by\n the C language standard for struct tm.  For example, the value of the\n field tm_year is the actual year, not year - 1900.  See individual\n fields' descriptions for details.")),
    ("time.struct_time.__class_getitem__", Some("See PEP 585")),
    ("time.struct_time.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("time.struct_time.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("time.struct_time.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("time.thread_time", Some("thread_time() -> float\n\nThread time for profiling: sum of the kernel and user-space CPU time.")),
    ("time.thread_time_ns", Some("thread_time() -> int\n\nThread time for profiling as nanoseconds:\nsum of the kernel and user-space CPU time.")),
    ("time.time", Some("time() -> floating point number\n\nReturn the current time in seconds since the Epoch.\nFractions of a second may be present if the system clock provides them.")),
    ("time.time_ns", Some("time_ns() -> int\n\nReturn the current time in nanoseconds since the Epoch.")),
    ("time.tzset", Some("tzset()\n\nInitialize, or reinitialize, the local timezone to the value stored in\nos.environ['TZ']. The TZ environment variable should be specified in\nstandard Unix timezone format as documented in the tzset man page\n(eg. 'US/Eastern', 'Europe/Amsterdam'). Unknown timezones will silently\nfall back to UTC. If the TZ environment variable is not set, the local\ntimezone is set to the systems best guess of wallclock time.\nChanging the TZ environment variable without calling tzset *may* change\nthe local timezone used by methods such as localtime, but this behaviour\nshould not be relied on.")),
    ("__hello__.TestFrozenUtf8_1", Some("\u{00b6}")),
    ("__hello__.TestFrozenUtf8_1.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("__hello__.TestFrozenUtf8_1.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("__hello__.TestFrozenUtf8_1.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("__hello__.TestFrozenUtf8_2", Some("\u{03c0}")),
    ("__hello__.TestFrozenUtf8_2.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("__hello__.TestFrozenUtf8_2.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("__hello__.TestFrozenUtf8_2.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("__hello__.TestFrozenUtf8_4.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("__hello__.TestFrozenUtf8_4.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("__hello__.TestFrozenUtf8_4.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_collections_abc", Some("Abstract Base Classes (ABCs) for collections, according to PEP 3119.\n\nUnit tests are in test_collections.\n")),
    ("_sitebuiltins", Some("\nThe objects used by the site module to add custom builtins.\n")),
    ("_sitebuiltins.Quitter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sitebuiltins.Quitter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sitebuiltins.Quitter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sitebuiltins._Helper", Some("Define the builtin 'help'.\n\n    This is a wrapper around pydoc.help that provides a helpful message\n    when 'help' is typed at the Python interactive prompt.\n\n    Calling help() at the Python prompt starts an interactive help session.\n    Calling help(thing) prints help for the python object 'thing'.\n    ")),
    ("_sitebuiltins._Helper.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sitebuiltins._Helper.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sitebuiltins._Helper.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sitebuiltins._Printer", Some("interactive prompt objects for printing the license text, a list of\n    contributors and the copyright notice.")),
    ("_sitebuiltins._Printer.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sitebuiltins._Printer.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sitebuiltins._Printer.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("abc", Some("Abstract Base Classes (ABCs) according to PEP 3119.")),
    ("abc.ABCMeta", Some("Metaclass for defining Abstract Base Classes (ABCs).\n\n        Use this metaclass to create an ABC.  An ABC can be subclassed\n        directly, and then acts as a mix-in class.  You can also register\n        unrelated concrete classes (even built-in classes) and unrelated\n        ABCs as 'virtual subclasses' -- these and their descendants will\n        be considered subclasses of the registering ABC by the built-in\n        issubclass() function, but the registering ABC won't show up in\n        their MRO (Method Resolution Order) nor will method\n        implementations defined by the registering ABC be callable (not\n        even via super()).\n        ")),
    ("abc.ABCMeta.__base__", Some("type(object) -> the object's type\ntype(name, bases, dict, **kwds) -> a new type")),
    ("abc.ABCMeta.__base__.__base__", Some("The base class of the class hierarchy.\n\nWhen called, it accepts no arguments and returns a new featureless\ninstance that has no instance attributes and cannot be given any.\n")),
    ("abc.ABCMeta.__base__.__base__.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("abc.ABCMeta.__base__.__base__.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("abc.ABCMeta.__base__.__base__.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("abc.ABCMeta.__base__.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("abc.ABCMeta.__base__.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("abc.ABCMeta.__base__.__prepare__", Some("__prepare__() -> dict\nused to create the namespace for the class statement")),
    ("abc.ABCMeta.__base__.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("abc.ABCMeta.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("abc.ABCMeta.__prepare__", Some("__prepare__() -> dict\nused to create the namespace for the class statement")),
    ("abc.ABCMeta.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("abc.abstractclassmethod", Some("A decorator indicating abstract classmethods.\n\n    Deprecated, use 'classmethod' with 'abstractmethod' instead:\n\n        class C(ABC):\n            @classmethod\n            @abstractmethod\n            def my_abstract_classmethod(cls, ...):\n                ...\n\n    ")),
    ("abc.abstractclassmethod.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("abc.abstractclassmethod.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("abc.abstractclassmethod.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("abc.abstractproperty", Some("A decorator indicating abstract properties.\n\n    Deprecated, use 'property' with 'abstractmethod' instead:\n\n        class C(ABC):\n            @property\n            @abstractmethod\n            def my_abstract_property(self):\n                ...\n\n    ")),
    ("abc.abstractproperty.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("abc.abstractproperty.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("abc.abstractproperty.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("abc.abstractstaticmethod", Some("A decorator indicating abstract staticmethods.\n\n    Deprecated, use 'staticmethod' with 'abstractmethod' instead:\n\n        class C(ABC):\n            @staticmethod\n            @abstractmethod\n            def my_abstract_staticmethod(...):\n                ...\n\n    ")),
    ("abc.abstractstaticmethod.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("abc.abstractstaticmethod.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("abc.abstractstaticmethod.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs", Some(" codecs -- Python Codec Registry, API and helpers.\n\n\nWritten by Marc-Andre Lemburg (mal@lemburg.com).\n\n(c) Copyright CNRI, All Rights Reserved. NO WARRANTY.\n\n")),
    ("codecs.BufferedIncrementalDecoder", Some("\n    This subclass of IncrementalDecoder can be used as the baseclass for an\n    incremental decoder if the decoder must be able to handle incomplete\n    byte sequences.\n    ")),
    ("codecs.BufferedIncrementalDecoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.BufferedIncrementalDecoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.BufferedIncrementalDecoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.BufferedIncrementalEncoder", Some("\n    This subclass of IncrementalEncoder can be used as the baseclass for an\n    incremental encoder if the encoder must keep some of the output in a\n    buffer between calls to encode().\n    ")),
    ("codecs.BufferedIncrementalEncoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.BufferedIncrementalEncoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.BufferedIncrementalEncoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.Codec", Some(" Defines the interface for stateless encoders/decoders.\n\n        The .encode()/.decode() methods may use different error\n        handling schemes by providing the errors argument. These\n        string values are predefined:\n\n         'strict' - raise a ValueError error (or a subclass)\n         'ignore' - ignore the character and continue with the next\n         'replace' - replace with a suitable replacement character;\n                    Python will use the official U+FFFD REPLACEMENT\n                    CHARACTER for the builtin Unicode codecs on\n                    decoding and '?' on encoding.\n         'surrogateescape' - replace with private code points U+DCnn.\n         'xmlcharrefreplace' - Replace with the appropriate XML\n                               character reference (only for encoding).\n         'backslashreplace'  - Replace with backslashed escape sequences.\n         'namereplace'       - Replace with \\N{...} escape sequences\n                               (only for encoding).\n\n        The set of allowed values can be extended via register_error.\n\n    ")),
    ("codecs.Codec.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.Codec.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.Codec.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.CodecInfo", Some("Codec details when looking up the codec registry")),
    ("codecs.CodecInfo.__class_getitem__", Some("See PEP 585")),
    ("codecs.CodecInfo.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.CodecInfo.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.IncrementalDecoder", Some("\n    An IncrementalDecoder decodes an input in multiple steps. The input can\n    be passed piece by piece to the decode() method. The IncrementalDecoder\n    remembers the state of the decoding process between calls to decode().\n    ")),
    ("codecs.IncrementalDecoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.IncrementalDecoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.IncrementalDecoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.IncrementalEncoder", Some("\n    An IncrementalEncoder encodes an input in multiple steps. The input can\n    be passed piece by piece to the encode() method. The IncrementalEncoder\n    remembers the state of the encoding process between calls to encode().\n    ")),
    ("codecs.IncrementalEncoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.IncrementalEncoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.IncrementalEncoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.StreamReader.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.StreamReader.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.StreamReader.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.StreamReader.charbuffertype", Some("str(object='') -> str\nstr(bytes_or_buffer[, encoding[, errors]]) -> str\n\nCreate a new string object from the given object. If encoding or\nerrors is specified, then the object must expose a data buffer\nthat will be decoded using the given encoding and error handler.\nOtherwise, returns the result of object.__str__() (if defined)\nor repr(object).\nencoding defaults to sys.getdefaultencoding().\nerrors defaults to 'strict'.")),
    ("codecs.StreamReader.charbuffertype.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.StreamReader.charbuffertype.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.StreamReader.charbuffertype.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.StreamReader.charbuffertype.maketrans", Some("Return a translation table usable for str.translate().\n\nIf there is only one argument, it must be a dictionary mapping Unicode\nordinals (integers) or characters to Unicode ordinals, strings or None.\nCharacter keys will be then converted to ordinals.\nIf there are two arguments, they must be strings of equal length, and\nin the resulting dictionary, each character in x will be mapped to the\ncharacter at the same position in y. If there is a third argument, it\nmust be a string, whose characters will be mapped to None in the result.")),
    ("codecs.StreamReaderWriter", Some(" StreamReaderWriter instances allow wrapping streams which\n        work in both read and write modes.\n\n        The design is such that one can use the factory functions\n        returned by the codec.lookup() function to construct the\n        instance.\n\n    ")),
    ("codecs.StreamReaderWriter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.StreamReaderWriter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.StreamReaderWriter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.StreamRecoder", Some(" StreamRecoder instances translate data from one encoding to another.\n\n        They use the complete set of APIs returned by the\n        codecs.lookup() function to implement their task.\n\n        Data written to the StreamRecoder is first decoded into an\n        intermediate format (depending on the \"decode\" codec) and then\n        written to the underlying stream using an instance of the provided\n        Writer class.\n\n        In the other direction, data is read from the underlying stream using\n        a Reader instance and then encoded and returned to the caller.\n\n    ")),
    ("codecs.StreamRecoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.StreamRecoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.StreamRecoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("codecs.StreamWriter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("codecs.StreamWriter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("codecs.StreamWriter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("genericpath", Some("\nPath operations common to more than one OS\nDo not use directly.  The OS specific modules import the appropriate\nfunctions from this module themselves.\n")),
    ("io", Some("The io module provides the Python interfaces to stream handling. The\nbuiltin open function is defined in this module.\n\nAt the top of the I/O hierarchy is the abstract base class IOBase. It\ndefines the basic interface to a stream. Note, however, that there is no\nseparation between reading and writing to streams; implementations are\nallowed to raise an OSError if they do not support a given operation.\n\nExtending IOBase is RawIOBase which deals simply with the reading and\nwriting of raw bytes to a stream. FileIO subclasses RawIOBase to provide\nan interface to OS files.\n\nBufferedIOBase deals with buffering on a raw byte stream (RawIOBase). Its\nsubclasses, BufferedWriter, BufferedReader, and BufferedRWPair buffer\nstreams that are readable, writable, and both respectively.\nBufferedRandom provides a buffered interface to random access\nstreams. BytesIO is a simple stream of in-memory bytes.\n\nAnother IOBase subclass, TextIOBase, deals with the encoding and decoding\nof streams into text. TextIOWrapper, which extends it, is a buffered text\ninterface to a buffered raw stream (`BufferedIOBase`). Finally, StringIO\nis an in-memory stream for text.\n\nArgument names are not part of the specification, and only the arguments\nof open() are intended to be used as keyword arguments.\n\ndata:\n\nDEFAULT_BUFFER_SIZE\n\n   An int containing the default buffer size used by the module's buffered\n   I/O classes. open() uses the file's blksize (as obtained by os.stat) if\n   possible.\n")),
    ("io.UnsupportedOperation.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("io.UnsupportedOperation.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("io.UnsupportedOperation.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("io.open", Some("Open file and return a stream.  Raise OSError upon failure.\n\nfile is either a text or byte string giving the name (and the path\nif the file isn't in the current working directory) of the file to\nbe opened or an integer file descriptor of the file to be\nwrapped. (If a file descriptor is given, it is closed when the\nreturned I/O object is closed, unless closefd is set to False.)\n\nmode is an optional string that specifies the mode in which the file\nis opened. It defaults to 'r' which means open for reading in text\nmode.  Other common values are 'w' for writing (truncating the file if\nit already exists), 'x' for creating and writing to a new file, and\n'a' for appending (which on some Unix systems, means that all writes\nappend to the end of the file regardless of the current seek position).\nIn text mode, if encoding is not specified the encoding used is platform\ndependent: locale.getencoding() is called to get the current locale encoding.\n(For reading and writing raw bytes use binary mode and leave encoding\nunspecified.) The available modes are:\n\n========= ===============================================================\nCharacter Meaning\n--------- ---------------------------------------------------------------\n'r'       open for reading (default)\n'w'       open for writing, truncating the file first\n'x'       create a new file and open it for writing\n'a'       open for writing, appending to the end of the file if it exists\n'b'       binary mode\n't'       text mode (default)\n'+'       open a disk file for updating (reading and writing)\n========= ===============================================================\n\nThe default mode is 'rt' (open for reading text). For binary random\naccess, the mode 'w+b' opens and truncates the file to 0 bytes, while\n'r+b' opens the file without truncation. The 'x' mode implies 'w' and\nraises an `FileExistsError` if the file already exists.\n\nPython distinguishes between files opened in binary and text modes,\neven when the underlying operating system doesn't. Files opened in\nbinary mode (appending 'b' to the mode argument) return contents as\nbytes objects without any decoding. In text mode (the default, or when\n't' is appended to the mode argument), the contents of the file are\nreturned as strings, the bytes having been first decoded using a\nplatform-dependent encoding or using the specified encoding if given.\n\nbuffering is an optional integer used to set the buffering policy.\nPass 0 to switch buffering off (only allowed in binary mode), 1 to select\nline buffering (only usable in text mode), and an integer > 1 to indicate\nthe size of a fixed-size chunk buffer.  When no buffering argument is\ngiven, the default buffering policy works as follows:\n\n* Binary files are buffered in fixed-size chunks; the size of the buffer\n  is chosen using a heuristic trying to determine the underlying device's\n  \"block size\" and falling back on `io.DEFAULT_BUFFER_SIZE`.\n  On many systems, the buffer will typically be 4096 or 8192 bytes long.\n\n* \"Interactive\" text files (files for which isatty() returns True)\n  use line buffering.  Other text files use the policy described above\n  for binary files.\n\nencoding is the name of the encoding used to decode or encode the\nfile. This should only be used in text mode. The default encoding is\nplatform dependent, but any encoding supported by Python can be\npassed.  See the codecs module for the list of supported encodings.\n\nerrors is an optional string that specifies how encoding errors are to\nbe handled---this argument should not be used in binary mode. Pass\n'strict' to raise a ValueError exception if there is an encoding error\n(the default of None has the same effect), or pass 'ignore' to ignore\nerrors. (Note that ignoring encoding errors can lead to data loss.)\nSee the documentation for codecs.register or run 'help(codecs.Codec)'\nfor a list of the permitted encoding error strings.\n\nnewline controls how universal newlines works (it only applies to text\nmode). It can be None, '', '\\n', '\\r', and '\\r\\n'.  It works as\nfollows:\n\n* On input, if newline is None, universal newlines mode is\n  enabled. Lines in the input can end in '\\n', '\\r', or '\\r\\n', and\n  these are translated into '\\n' before being returned to the\n  caller. If it is '', universal newline mode is enabled, but line\n  endings are returned to the caller untranslated. If it has any of\n  the other legal values, input lines are only terminated by the given\n  string, and the line ending is returned to the caller untranslated.\n\n* On output, if newline is None, any '\\n' characters written are\n  translated to the system default line separator, os.linesep. If\n  newline is '' or '\\n', no translation takes place. If newline is any\n  of the other legal values, any '\\n' characters written are translated\n  to the given string.\n\nIf closefd is False, the underlying file descriptor will be kept open\nwhen the file is closed. This does not work when a file name is given\nand must be True in that case.\n\nA custom opener can be used by passing a callable as *opener*. The\nunderlying file descriptor for the file object is then obtained by\ncalling *opener* with (*file*, *flags*). *opener* must return an open\nfile descriptor (passing os.open as *opener* results in functionality\nsimilar to passing None).\n\nopen() returns a file object whose type depends on the mode, and\nthrough which the standard file operations such as reading and writing\nare performed. When open() is used to open a file in a text mode ('w',\n'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open\na file in a binary mode, the returned class varies: in read binary\nmode, it returns a BufferedReader; in write binary and append binary\nmodes, it returns a BufferedWriter, and in read/write mode, it returns\na BufferedRandom.\n\nIt is also possible to use a string or bytearray as a file for both\nreading and writing. For strings StringIO can be used like a file\nopened in a text mode, and for bytes a BytesIO can be used like a file\nopened in a binary mode.")),
    ("io.open_code", Some("Opens the provided file with the intent to import the contents.\n\nThis may perform extra validation beyond open(), but is otherwise interchangeable\nwith calling open(path, 'rb').")),
    ("io.text_encoding", Some("A helper function to choose the text encoding.\n\nWhen encoding is not None, this function returns it.\nOtherwise, this function returns the default text encoding\n(i.e. \"locale\" or \"utf-8\" depends on UTF-8 mode).\n\nThis function emits an EncodingWarning if encoding is None and\nsys.flags.warn_default_encoding is true.\n\nThis can be used in APIs with an encoding=None parameter.\nHowever, please consider using encoding=\"utf-8\" for new APIs.")),
    ("ntpath", Some("Common pathname manipulations, WindowsNT/95 version.\n\nInstead of importing this module directly, import os and refer to this\nmodule as os.path.\n")),
    ("os", Some("OS routines for NT or Posix depending on what system we're on.\n\nThis exports:\n  - all functions from posix or nt, e.g. unlink, stat, etc.\n  - os.path is either posixpath or ntpath\n  - os.name is either 'posix' or 'nt'\n  - os.curdir is a string representing the current directory (always '.')\n  - os.pardir is a string representing the parent directory (always '..')\n  - os.sep is the (or a most common) pathname separator ('/' or '\\\\')\n  - os.extsep is the extension separator (always '.')\n  - os.altsep is the alternate pathname separator (None or '/')\n  - os.pathsep is the component separator used in $PATH etc\n  - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')\n  - os.defpath is the default search path for executables\n  - os.devnull is the file path of the null device ('/dev/null', etc.)\n\nPrograms that import and use 'os' stand a better chance of being\nportable between different platforms.  Of course, they must then\nonly use functions that are defined by all platforms (e.g., unlink\nand opendir), and leave all pathname manipulation to os.path\n(e.g., split and join).\n")),
    ("os._wrap_close.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("os._wrap_close.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("os._wrap_close.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("os.stat_result", Some("stat_result: Result from stat, fstat, or lstat.\n\nThis object may be accessed either as a tuple of\n  (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\nor via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n\nPosix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\nor st_flags, they are available as attributes only.\n\nSee os.stat for more information.")),
    ("os.stat_result.__class_getitem__", Some("See PEP 585")),
    ("os.stat_result.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("os.stat_result.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("os.stat_result.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("os.statvfs_result", Some("statvfs_result: Result from statvfs or fstatvfs.\n\nThis object may be accessed either as a tuple of\n  (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\nor via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n\nSee os.statvfs for more information.")),
    ("os.statvfs_result.__class_getitem__", Some("See PEP 585")),
    ("os.statvfs_result.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("os.statvfs_result.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("os.statvfs_result.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("os.terminal_size", Some("A tuple of (columns, lines) for holding terminal window size")),
    ("os.terminal_size.__class_getitem__", Some("See PEP 585")),
    ("os.terminal_size.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("os.terminal_size.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("os.terminal_size.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("posixpath", Some("Common operations on Posix pathnames.\n\nInstead of importing this module directly, import os and refer to\nthis module as os.path.  The \"os.path\" name is an alias for this\nmodule on Posix systems; on other systems (e.g. Windows),\nos.path provides the same operations in a manner specific to that\nplatform, and is an alias to another module (e.g. ntpath).\n\nSome of this can actually be useful on non-Posix systems too, e.g.\nfor manipulation of the pathname component of URLs.\n")),
    ("runpy", Some("runpy.py - locating and running Python code using the module namespace\n\nProvides support for locating and running Python scripts using the Python\nmodule namespace instead of the native filesystem.\n\nThis allows Python code to play nicely with non-filesystem based PEP 302\nimporters when locating support scripts as well as when importing modules.\n")),
    ("runpy._Error", Some("Error that _run_module_as_main() should report without a traceback")),
    ("runpy._Error.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("runpy._Error.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("runpy._Error.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("runpy._ModifiedArgv0.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("runpy._ModifiedArgv0.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("runpy._ModifiedArgv0.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("runpy._TempModule", Some("Temporarily replace a module in sys.modules with an empty namespace")),
    ("runpy._TempModule.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("runpy._TempModule.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("runpy._TempModule.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("site", Some("Append module search paths for third-party packages to sys.path.\n\n****************************************************************\n* This module is automatically imported during initialization. *\n****************************************************************\n\nThis will append site-specific paths to the module search path.  On\nUnix (including Mac OSX), it starts with sys.prefix and\nsys.exec_prefix (if different) and appends\nlib/python<version>/site-packages.\nOn other platforms (such as Windows), it tries each of the\nprefixes directly, as well as with lib/site-packages appended.  The\nresulting directories, if they exist, are appended to sys.path, and\nalso inspected for path configuration files.\n\nIf a file named \"pyvenv.cfg\" exists one directory above sys.executable,\nsys.prefix and sys.exec_prefix are set to that directory and\nit is also checked for site-packages (sys.base_prefix and\nsys.base_exec_prefix will always be the \"real\" prefixes of the Python\ninstallation). If \"pyvenv.cfg\" (a bootstrap configuration file) contains\nthe key \"include-system-site-packages\" set to anything other than \"false\"\n(case-insensitive), the system-level prefixes will still also be\nsearched for site-packages; otherwise they won't.\n\nAll of the resulting site-specific directories, if they exist, are\nappended to sys.path, and also inspected for path configuration\nfiles.\n\nA path configuration file is a file whose name has the form\n<package>.pth; its contents are additional directories (one per line)\nto be added to sys.path.  Non-existing directories (or\nnon-directories) are never added to sys.path; no directory is added to\nsys.path more than once.  Blank lines and lines beginning with\n'#' are skipped. Lines starting with 'import' are executed.\n\nFor example, suppose sys.prefix and sys.exec_prefix are set to\n/usr/local and there is a directory /usr/local/lib/python2.5/site-packages\nwith three subdirectories, foo, bar and spam, and two path\nconfiguration files, foo.pth and bar.pth.  Assume foo.pth contains the\nfollowing:\n\n  # foo package configuration\n  foo\n  bar\n  bletch\n\nand bar.pth contains:\n\n  # bar package configuration\n  bar\n\nThen the following directories are added to sys.path, in this order:\n\n  /usr/local/lib/python2.5/site-packages/bar\n  /usr/local/lib/python2.5/site-packages/foo\n\nNote that bletch is omitted because it doesn't exist; bar precedes foo\nbecause bar.pth comes alphabetically before foo.pth; and spam is\nomitted because it is not mentioned in either path configuration file.\n\nThe readline module is also automatically configured to enable\ncompletion for systems that support it.  This can be overridden in\nsitecustomize, usercustomize or PYTHONSTARTUP.  Starting Python in\nisolated mode (-I) disables automatic readline configuration.\n\nAfter these operations, an attempt is made to import a module\nnamed sitecustomize, which can perform arbitrary additional\nsite-specific customizations.  If this import fails with an\nImportError exception, it is silently ignored.\n")),
    ("stat", Some("Constants/functions for interpreting results of os.stat() and os.lstat().\n\nSuggested usage: from stat import *\n")),
    ("zipimport", Some("zipimport provides support for importing Python modules from Zip archives.\n\nThis module exports three objects:\n- zipimporter: a class; its constructor takes a path to a Zip archive.\n- ZipImportError: exception raised by zipimporter objects. It's a\n  subclass of ImportError, so it can be caught as ImportError, too.\n- _zip_directory_cache: a dict, mapping archive paths to zip directory\n  info dicts, as used in zipimporter._files.\n\nIt is usually not needed to use the zipimport module explicitly; it is\nused by the builtin import mechanism for sys.path items that are paths\nto Zip archives.\n")),
    ("zipimport.ZipImportError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("zipimport.ZipImportError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("zipimport.ZipImportError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("zipimport.zipimporter", Some("zipimporter(archivepath) -> zipimporter object\n\n    Create a new zipimporter instance. 'archivepath' must be a path to\n    a zipfile, or to a specific path inside a zipfile. For example, it can be\n    '/tmp/myimport.zip', or '/tmp/myimport.zip/mydirectory', if mydirectory is a\n    valid directory inside the archive.\n\n    'ZipImportError is raised if 'archivepath' doesn't point to a valid Zip\n    archive.\n\n    The 'archive' attribute of zipimporter objects contains the name of the\n    zipfile targeted.\n    ")),
    ("zipimport.zipimporter.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("zipimport.zipimporter.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("zipimport.zipimporter.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_asyncio", Some("Accelerator module for asyncio")),
    ("_asyncio.Future", Some("This class is *almost* compatible with concurrent.futures.Future.\n\n    Differences:\n\n    - result() and exception() do not take a timeout argument and\n      raise an exception when the future isn't done yet.\n\n    - Callbacks registered with add_done_callback() are always called\n      via the event loop's call_soon_threadsafe().\n\n    - This class is not compatible with the wait() and as_completed()\n      methods in the concurrent.futures package.")),
    ("_asyncio.Future.__class_getitem__", Some("See PEP 585")),
    ("_asyncio.Future.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_asyncio.Future.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_asyncio.Future.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_asyncio.Task", Some("A coroutine wrapped in a Future.")),
    ("_asyncio.Task.__class_getitem__", Some("See PEP 585")),
    ("_asyncio.Task.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_asyncio.Task.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_asyncio.Task.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_asyncio._enter_task", Some("Enter into task execution or resume suspended task.\n\nTask belongs to loop.\n\nReturns None.")),
    ("_asyncio._get_event_loop", None),
    ("_asyncio._get_running_loop", Some("Return the running event loop or None.\n\nThis is a low-level function intended to be used by event loops.\nThis function is thread-specific.")),
    ("_asyncio._leave_task", Some("Leave task execution or suspend a task.\n\nTask belongs to loop.\n\nReturns None.")),
    ("_asyncio._register_task", Some("Register a new task in asyncio as executed by loop.\n\nReturns None.")),
    ("_asyncio._set_running_loop", Some("Set the running event loop.\n\nThis is a low-level function intended to be used by event loops.\nThis function is thread-specific.")),
    ("_asyncio._unregister_task", Some("Unregister a task.\n\nReturns None.")),
    ("_asyncio.get_event_loop", Some("Return an asyncio event loop.\n\nWhen called from a coroutine or a callback (e.g. scheduled with\ncall_soon or similar API), this function will always return the\nrunning event loop.\n\nIf there is no running event loop set, the function will return\nthe result of `get_event_loop_policy().get_event_loop()` call.")),
    ("_asyncio.get_running_loop", Some("Return the running event loop.  Raise a RuntimeError if there is none.\n\nThis function is thread-specific.")),
    ("_bisect", Some("Bisection algorithms.\n\nThis module provides support for maintaining a list in sorted order without\nhaving to sort the list after each insertion. For long lists of items with\nexpensive comparison operations, this can be an improvement over the more\ncommon approach.\n")),
    ("_bisect.bisect_left", Some("Return the index where to insert item x in list a, assuming a is sorted.\n\nThe return value i is such that all e in a[:i] have e < x, and all e in\na[i:] have e >= x.  So if x already appears in the list, a.insert(i, x) will\ninsert just before the leftmost x already there.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.")),
    ("_bisect.bisect_right", Some("Return the index where to insert item x in list a, assuming a is sorted.\n\nThe return value i is such that all e in a[:i] have e <= x, and all e in\na[i:] have e > x.  So if x already appears in the list, a.insert(i, x) will\ninsert just after the rightmost x already there.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.")),
    ("_bisect.insort_left", Some("Insert item x in list a, and keep it sorted assuming a is sorted.\n\nIf x is already in a, insert it to the left of the leftmost x.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.")),
    ("_bisect.insort_right", Some("Insert item x in list a, and keep it sorted assuming a is sorted.\n\nIf x is already in a, insert it to the right of the rightmost x.\n\nOptional args lo (default 0) and hi (default len(a)) bound the\nslice of a to be searched.")),
    ("_blake2", Some("_blake2b provides BLAKE2b for hashlib\n")),
    ("_blake2.blake2b", Some("Return a new BLAKE2b hash object.")),
    ("_blake2.blake2b.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_blake2.blake2b.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_blake2.blake2b.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_blake2.blake2s", Some("Return a new BLAKE2s hash object.")),
    ("_blake2.blake2s.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_blake2.blake2s.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_blake2.blake2s.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_bz2.BZ2Compressor", Some("Create a compressor object for compressing data incrementally.\n\n  compresslevel\n    Compression level, as a number between 1 and 9.\n\nFor one-shot compression, use the compress() function instead.")),
    ("_bz2.BZ2Compressor.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_bz2.BZ2Compressor.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_bz2.BZ2Compressor.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_bz2.BZ2Decompressor", Some("Create a decompressor object for decompressing data incrementally.\n\nFor one-shot decompression, use the decompress() function instead.")),
    ("_bz2.BZ2Decompressor.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_bz2.BZ2Decompressor.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_bz2.BZ2Decompressor.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_contextvars", Some("Context Variables")),
    ("_contextvars.Context.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_contextvars.Context.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_contextvars.Context.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_contextvars.ContextVar.__class_getitem__", Some("See PEP 585")),
    ("_contextvars.ContextVar.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_contextvars.ContextVar.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_contextvars.ContextVar.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_contextvars.Token.__class_getitem__", Some("See PEP 585")),
    ("_contextvars.Token.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_contextvars.Token.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_contextvars.Token.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_contextvars.copy_context", None),
    ("_csv", Some("CSV parsing and writing.\n\nThis module provides classes that assist in the reading and writing\nof Comma Separated Value (CSV) files, and implements the interface\ndescribed by PEP 305.  Although many CSV files are simple to parse,\nthe format is not formally defined by a stable specification and\nis subtle enough that parsing lines of a CSV file with something\nlike line.split(\",\") is bound to fail.  The module supports three\nbasic APIs: reading, writing, and registration of dialects.\n\n\nDIALECT REGISTRATION:\n\nReaders and writers support a dialect argument, which is a convenient\nhandle on a group of settings.  When the dialect argument is a string,\nit identifies one of the dialects previously registered with the module.\nIf it is a class or instance, the attributes of the argument are used as\nthe settings for the reader or writer:\n\n    class excel:\n        delimiter = ','\n        quotechar = '\"'\n        escapechar = None\n        doublequote = True\n        skipinitialspace = False\n        lineterminator = '\\r\\n'\n        quoting = QUOTE_MINIMAL\n\nSETTINGS:\n\n    * quotechar - specifies a one-character string to use as the\n        quoting character.  It defaults to '\"'.\n    * delimiter - specifies a one-character string to use as the\n        field separator.  It defaults to ','.\n    * skipinitialspace - specifies how to interpret spaces which\n        immediately follow a delimiter.  It defaults to False, which\n        means that spaces immediately following a delimiter is part\n        of the following field.\n    * lineterminator -  specifies the character sequence which should\n        terminate rows.\n    * quoting - controls when quotes should be generated by the writer.\n        It can take on any of the following module constants:\n\n        csv.QUOTE_MINIMAL means only when required, for example, when a\n            field contains either the quotechar or the delimiter\n        csv.QUOTE_ALL means that quotes are always placed around fields.\n        csv.QUOTE_NONNUMERIC means that quotes are always placed around\n            fields which do not parse as integers or floating point\n            numbers.\n        csv.QUOTE_NONE means that quotes are never placed around fields.\n    * escapechar - specifies a one-character string used to escape\n        the delimiter when quoting is set to QUOTE_NONE.\n    * doublequote - controls the handling of quotes inside fields.  When\n        True, two consecutive quotes are interpreted as one during read,\n        and when writing, each quote character embedded in the data is\n        written as two quotes\n")),
    ("_csv.Dialect", Some("CSV dialect\n\nThe Dialect type records CSV parsing and generation options.\n")),
    ("_csv.Dialect.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_csv.Dialect.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_csv.Dialect.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_csv.Error.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_csv.Error.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_csv.Error.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_csv.Reader", Some("CSV reader\n\nReader objects are responsible for reading and parsing tabular data\nin CSV format.\n")),
    ("_csv.Reader.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_csv.Reader.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_csv.Reader.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_csv.Writer", Some("CSV writer\n\nWriter objects are responsible for generating tabular data\nin CSV format from sequence input.\n")),
    ("_csv.Writer.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_csv.Writer.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_csv.Writer.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_csv.field_size_limit", Some("Sets an upper limit on parsed fields.\n\n    csv.field_size_limit([limit])\n\nReturns old limit. If limit is not given, no new limit is set and\nthe old limit is returned")),
    ("_csv.get_dialect", Some("Return the dialect instance associated with name.\n\n    dialect = csv.get_dialect(name)")),
    ("_csv.list_dialects", Some("Return a list of all known dialect names.\n\n    names = csv.list_dialects()")),
    ("_csv.reader", Some("    csv_reader = reader(iterable [, dialect='excel']\n                        [optional keyword args])\n    for row in csv_reader:\n        process(row)\n\nThe \"iterable\" argument can be any object that returns a line\nof input for each iteration, such as a file object or a list.  The\noptional \"dialect\" parameter is discussed below.  The function\nalso accepts optional keyword arguments which override settings\nprovided by the dialect.\n\nThe returned object is an iterator.  Each iteration returns a row\nof the CSV file (which can span multiple input lines).\n")),
    ("_csv.register_dialect", Some("Create a mapping from a string name to a dialect class.\n    dialect = csv.register_dialect(name[, dialect[, **fmtparams]])")),
    ("_csv.unregister_dialect", Some("Delete the name/dialect mapping associated with a string name.\n\n    csv.unregister_dialect(name)")),
    ("_csv.writer", Some("    csv_writer = csv.writer(fileobj [, dialect='excel']\n                            [optional keyword args])\n    for row in sequence:\n        csv_writer.writerow(row)\n\n    [or]\n\n    csv_writer = csv.writer(fileobj [, dialect='excel']\n                            [optional keyword args])\n    csv_writer.writerows(rows)\n\nThe \"fileobj\" argument can be any object that supports the file API.\n")),
    ("_ctypes", Some("Create and manipulate C compatible data types in Python.")),
    ("_ctypes.POINTER", None),
    ("_ctypes.PyObj_FromPtr", None),
    ("_ctypes.Py_DECREF", None),
    ("_ctypes.Py_INCREF", None),
    ("_ctypes._dyld_shared_cache_contains_path", Some("check if path is in the shared cache")),
    ("_ctypes._unpickle", None),
    ("_ctypes.addressof", Some("addressof(C instance) -> integer\nReturn the address of the C instance internal buffer")),
    ("_ctypes.alignment", Some("alignment(C type) -> integer\nalignment(C instance) -> integer\nReturn the alignment requirements of a C instance")),
    ("_ctypes.buffer_info", Some("Return buffer interface information")),
    ("_ctypes.byref", Some("byref(C instance[, offset=0]) -> byref-object\nReturn a pointer lookalike to a C instance, only usable\nas function argument")),
    ("_ctypes.call_cdeclfunction", None),
    ("_ctypes.call_function", None),
    ("_ctypes.dlclose", Some("dlclose a library")),
    ("_ctypes.dlopen", Some("dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library")),
    ("_ctypes.dlsym", Some("find symbol in shared library")),
    ("_ctypes.get_errno", None),
    ("_ctypes.pointer", None),
    ("_ctypes.resize", Some("Resize the memory buffer of a ctypes instance")),
    ("_ctypes.set_errno", None),
    ("_ctypes.sizeof", Some("sizeof(C type) -> integer\nsizeof(C instance) -> integer\nReturn the size in bytes of a C instance")),
    ("_datetime", Some("Fast implementation of the datetime type.")),
    ("_dbm.error.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_dbm.error.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_dbm.error.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_dbm.open", Some("Return a database object.\n\n  filename\n    The filename to open.\n  flags\n    How to open the file.  \"r\" for reading, \"w\" for writing, etc.\n  mode\n    If creating a new file, the mode bits for the new file\n    (e.g. os.O_RDWR).")),
    ("_decimal", Some("C decimal arithmetic module")),
    ("_hashlib", Some("OpenSSL interface for hashlib module")),
    ("_hashlib.HASH", Some("A hash is an object used to calculate a checksum of a string of information.\n\nMethods:\n\nupdate() -- updates the current digest with an additional string\ndigest() -- return the current digest value\nhexdigest() -- return the current digest as a string of hexadecimal digits\ncopy() -- return a copy of the current hash object\n\nAttributes:\n\nname -- the hash algorithm being used by this object\ndigest_size -- number of bytes in this hashes output")),
    ("_hashlib.HASH.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_hashlib.HASH.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_hashlib.HASH.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_hashlib.HASHXOF", Some("A hash is an object used to calculate a checksum of a string of information.\n\nMethods:\n\nupdate() -- updates the current digest with an additional string\ndigest(length) -- return the current digest value\nhexdigest(length) -- return the current digest as a string of hexadecimal digits\ncopy() -- return a copy of the current hash object\n\nAttributes:\n\nname -- the hash algorithm being used by this object\ndigest_size -- number of bytes in this hashes output")),
    ("_hashlib.HASHXOF.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_hashlib.HASHXOF.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_hashlib.HASHXOF.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_hashlib.HMAC", Some("The object used to calculate HMAC of a message.\n\nMethods:\n\nupdate() -- updates the current digest with an additional string\ndigest() -- return the current digest value\nhexdigest() -- return the current digest as a string of hexadecimal digits\ncopy() -- return a copy of the current hash object\n\nAttributes:\n\nname -- the name, including the hash algorithm used by this object\ndigest_size -- number of bytes in digest() output\n")),
    ("_hashlib.HMAC.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_hashlib.HMAC.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_hashlib.HMAC.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_hashlib.UnsupportedDigestmodError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_hashlib.UnsupportedDigestmodError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_hashlib.UnsupportedDigestmodError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_hashlib.compare_digest", Some("Return 'a == b'.\n\nThis function uses an approach designed to prevent\ntiming analysis, making it appropriate for cryptography.\n\na and b must both be of the same type: either str (ASCII only),\nor any bytes-like object.\n\nNote: If a and b are of different lengths, or if an error occurs,\na timing attack could theoretically reveal information about the\ntypes and lengths of a and b--but not their values.")),
    ("_hashlib.get_fips_mode", Some("Determine the OpenSSL FIPS mode of operation.\n\nFor OpenSSL 3.0.0 and newer it returns the state of the default provider\nin the default OSSL context. It's not quite the same as FIPS_mode() but good\nenough for unittests.\n\nEffectively any non-zero return value indicates FIPS mode;\nvalues other than 1 may have additional significance.")),
    ("_hashlib.hmac_digest", Some("Single-shot HMAC.")),
    ("_hashlib.hmac_new", Some("Return a new hmac object.")),
    ("_hashlib.new", Some("Return a new hash object using the named algorithm.\n\nAn optional string argument may be provided and will be\nautomatically hashed.\n\nThe MD5 and SHA1 algorithms are always supported.")),
    ("_hashlib.openssl_md5", Some("Returns a md5 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha1", Some("Returns a sha1 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha224", Some("Returns a sha224 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha256", Some("Returns a sha256 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha384", Some("Returns a sha384 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha3_224", Some("Returns a sha3-224 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha3_256", Some("Returns a sha3-256 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha3_384", Some("Returns a sha3-384 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha3_512", Some("Returns a sha3-512 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_sha512", Some("Returns a sha512 hash object; optionally initialized with a string")),
    ("_hashlib.openssl_shake_128", Some("Returns a shake-128 variable hash object; optionally initialized with a string")),
    ("_hashlib.openssl_shake_256", Some("Returns a shake-256 variable hash object; optionally initialized with a string")),
    ("_hashlib.pbkdf2_hmac", Some("Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.")),
    ("_hashlib.scrypt", Some("scrypt password-based key derivation function.")),
    ("_heapq", Some("Heap queue algorithm (a.k.a. priority queue).\n\nHeaps are arrays for which a[k] <= a[2*k+1] and a[k] <= a[2*k+2] for\nall k, counting elements from 0.  For the sake of comparison,\nnon-existing elements are considered to be infinite.  The interesting\nproperty of a heap is that a[0] is always its smallest element.\n\nUsage:\n\nheap = []            # creates an empty heap\nheappush(heap, item) # pushes a new item on the heap\nitem = heappop(heap) # pops the smallest item from the heap\nitem = heap[0]       # smallest item on the heap without popping it\nheapify(x)           # transforms list into a heap, in-place, in linear time\nitem = heapreplace(heap, item) # pops and returns smallest item, and adds\n                               # new item; the heap size is unchanged\n\nOur API differs from textbook heap algorithms as follows:\n\n- We use 0-based indexing.  This makes the relationship between the\n  index for a node and the indexes for its children slightly less\n  obvious, but is more suitable since Python uses 0-based indexing.\n\n- Our heappop() method returns the smallest item, not the largest.\n\nThese two make it possible to view the heap as a regular Python list\nwithout surprises: heap[0] is the smallest item, and heap.sort()\nmaintains the heap invariant!\n")),
    ("_heapq._heapify_max", Some("Maxheap variant of heapify.")),
    ("_heapq._heappop_max", Some("Maxheap variant of heappop.")),
    ("_heapq._heapreplace_max", Some("Maxheap variant of heapreplace.")),
    ("_heapq.heapify", Some("Transform list into a heap, in-place, in O(len(heap)) time.")),
    ("_heapq.heappop", Some("Pop the smallest item off the heap, maintaining the heap invariant.")),
    ("_heapq.heappush", Some("Push item onto heap, maintaining the heap invariant.")),
    ("_heapq.heappushpop", Some("Push item on the heap, then pop and return the smallest item from the heap.\n\nThe combined action runs more efficiently than heappush() followed by\na separate call to heappop().")),
    ("_heapq.heapreplace", Some("Pop and return the current smallest value, and add the new item.\n\nThis is more efficient than heappop() followed by heappush(), and can be\nmore appropriate when using a fixed-size heap.  Note that the value\nreturned may be larger than item!  That constrains reasonable uses of\nthis routine unless written as part of a conditional replacement:\n\n    if item > heap[0]:\n        item = heapreplace(heap, item)")),
    ("_json", Some("json speedups\n")),
    ("_json.encode_basestring", Some("encode_basestring(string) -> string\n\nReturn a JSON representation of a Python string")),
    ("_json.encode_basestring_ascii", Some("encode_basestring_ascii(string) -> string\n\nReturn an ASCII-only JSON representation of a Python string")),
    ("_json.make_encoder", Some("_iterencode(obj, _current_indent_level) -> iterable")),
    ("_json.make_encoder.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_json.make_encoder.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_json.make_encoder.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_json.make_scanner", Some("JSON scanner object")),
    ("_json.make_scanner.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_json.make_scanner.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_json.make_scanner.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_json.scanstring", Some("scanstring(string, end, strict=True) -> (string, end)\n\nScan the string s for a JSON string. End is the index of the\ncharacter in s after the quote that started the JSON string.\nUnescapes all valid JSON string escape sequences and raises ValueError\non attempt to decode an invalid string. If strict is False then literal\ncontrol characters are allowed in the string.\n\nReturns a tuple of the decoded string and the index of the character in s\nafter the end quote.")),
    ("_md5.MD5Type.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_md5.MD5Type.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_md5.MD5Type.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_md5.md5", Some("Return a new MD5 hash object; optionally initialized with a string.")),
    ("_multiprocessing.SemLock", Some("Semaphore/Mutex type")),
    ("_multiprocessing.SemLock.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_multiprocessing.SemLock.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_multiprocessing.SemLock.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_multiprocessing.SemLock._rebuild", None),
    ("_multiprocessing.sem_unlink", None),
    ("_opcode", Some("Opcode support module.")),
    ("_opcode.get_specialization_stats", Some("Return the specialization stats")),
    ("_opcode.stack_effect", Some("Compute the stack effect of the opcode.")),
    ("_pickle", Some("Optimized C implementation for the Python pickle module.")),
    ("_pickle.PickleError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_pickle.PickleError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_pickle.PickleError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_pickle.Pickler", Some("This takes a binary file for writing a pickle data stream.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 4. It was introduced in Python 3.4, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nThe *file* argument must have a write() method that accepts a single\nbytes argument. It can thus be a file object opened for binary\nwriting, an io.BytesIO instance, or any other custom object that meets\nthis interface.\n\nIf *fix_imports* is True and protocol is less than 3, pickle will try\nto map the new Python 3 names to the old module names used in Python\n2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are\nserialized into *file* as part of the pickle stream.\n\nIf *buffer_callback* is not None, then it can be called any number\nof times with a buffer view.  If the callback returns a false value\n(such as None), the given buffer is out-of-band; otherwise the\nbuffer is serialized in-band, i.e. inside the pickle stream.\n\nIt is an error if *buffer_callback* is not None and *protocol*\nis None or smaller than 5.")),
    ("_pickle.Pickler.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_pickle.Pickler.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_pickle.Pickler.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_pickle.PicklingError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_pickle.PicklingError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_pickle.PicklingError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_pickle.Unpickler", Some("This takes a binary file for reading a pickle data stream.\n\nThe protocol version of the pickle is detected automatically, so no\nprotocol argument is needed.  Bytes past the pickled object's\nrepresentation are ignored.\n\nThe argument *file* must have two methods, a read() method that takes\nan integer argument, and a readline() method that requires no\narguments.  Both methods should return bytes.  Thus *file* can be a\nbinary file object opened for reading, an io.BytesIO object, or any\nother custom object that meets this interface.\n\nOptional keyword arguments are *fix_imports*, *encoding* and *errors*,\nwhich are used to control compatibility support for pickle stream\ngenerated by Python 2.  If *fix_imports* is True, pickle will try to\nmap the old Python 2 names to the new names used in Python 3.  The\n*encoding* and *errors* tell pickle how to decode 8-bit string\ninstances pickled by Python 2; these default to 'ASCII' and 'strict',\nrespectively.  The *encoding* can be 'bytes' to read these 8-bit\nstring instances as bytes objects.")),
    ("_pickle.Unpickler.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_pickle.Unpickler.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_pickle.Unpickler.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_pickle.UnpicklingError.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_pickle.UnpicklingError.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_pickle.UnpicklingError.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_pickle.dump", Some("Write a pickled representation of obj to the open file object file.\n\nThis is equivalent to ``Pickler(file, protocol).dump(obj)``, but may\nbe more efficient.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 4. It was introduced in Python 3.4, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nThe *file* argument must have a write() method that accepts a single\nbytes argument.  It can thus be a file object opened for binary\nwriting, an io.BytesIO instance, or any other custom object that meets\nthis interface.\n\nIf *fix_imports* is True and protocol is less than 3, pickle will try\nto map the new Python 3 names to the old module names used in Python\n2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are serialized\ninto *file* as part of the pickle stream.  It is an error if\n*buffer_callback* is not None and *protocol* is None or smaller than 5.")),
    ("_pickle.dumps", Some("Return the pickled representation of the object as a bytes object.\n\nThe optional *protocol* argument tells the pickler to use the given\nprotocol; supported protocols are 0, 1, 2, 3, 4 and 5.  The default\nprotocol is 4. It was introduced in Python 3.4, and is incompatible\nwith previous versions.\n\nSpecifying a negative protocol version selects the highest protocol\nversion supported.  The higher the protocol used, the more recent the\nversion of Python needed to read the pickle produced.\n\nIf *fix_imports* is True and *protocol* is less than 3, pickle will\ntry to map the new Python 3 names to the old module names used in\nPython 2, so that the pickle data stream is readable with Python 2.\n\nIf *buffer_callback* is None (the default), buffer views are serialized\ninto *file* as part of the pickle stream.  It is an error if\n*buffer_callback* is not None and *protocol* is None or smaller than 5.")),
    ("_pickle.load", Some("Read and return an object from the pickle data stored in a file.\n\nThis is equivalent to ``Unpickler(file).load()``, but may be more\nefficient.\n\nThe protocol version of the pickle is detected automatically, so no\nprotocol argument is needed.  Bytes past the pickled object's\nrepresentation are ignored.\n\nThe argument *file* must have two methods, a read() method that takes\nan integer argument, and a readline() method that requires no\narguments.  Both methods should return bytes.  Thus *file* can be a\nbinary file object opened for reading, an io.BytesIO object, or any\nother custom object that meets this interface.\n\nOptional keyword arguments are *fix_imports*, *encoding* and *errors*,\nwhich are used to control compatibility support for pickle stream\ngenerated by Python 2.  If *fix_imports* is True, pickle will try to\nmap the old Python 2 names to the new names used in Python 3.  The\n*encoding* and *errors* tell pickle how to decode 8-bit string\ninstances pickled by Python 2; these default to 'ASCII' and 'strict',\nrespectively.  The *encoding* can be 'bytes' to read these 8-bit\nstring instances as bytes objects.")),
    ("_pickle.loads", Some("Read and return an object from the given pickle data.\n\nThe protocol version of the pickle is detected automatically, so no\nprotocol argument is needed.  Bytes past the pickled object's\nrepresentation are ignored.\n\nOptional keyword arguments are *fix_imports*, *encoding* and *errors*,\nwhich are used to control compatibility support for pickle stream\ngenerated by Python 2.  If *fix_imports* is True, pickle will try to\nmap the old Python 2 names to the new names used in Python 3.  The\n*encoding* and *errors* tell pickle how to decode 8-bit string\ninstances pickled by Python 2; these default to 'ASCII' and 'strict',\nrespectively.  The *encoding* can be 'bytes' to read these 8-bit\nstring instances as bytes objects.")),
    ("_posixsubprocess", Some("A POSIX helper for the subprocess module.")),
    ("_posixsubprocess.fork_exec", Some("fork_exec(args, executable_list, close_fds, pass_fds, cwd, env,\n          p2cread, p2cwrite, c2pread, c2pwrite,\n          errread, errwrite, errpipe_read, errpipe_write,\n          restore_signals, call_setsid, pgid_to_set,\n          gid, groups_list, uid,\n          preexec_fn)\n\nForks a child process, closes parent file descriptors as appropriate in the\nchild and dups the few that are needed before calling exec() in the child\nprocess.\n\nIf close_fds is true, close file descriptors 3 and higher, except those listed\nin the sorted tuple pass_fds.\n\nThe preexec_fn, if supplied, will be called immediately before closing file\ndescriptors and exec.\nWARNING: preexec_fn is NOT SAFE if your application uses threads.\n         It may trigger infrequent, difficult to debug deadlocks.\n\nIf an error occurs in the child process before the exec, it is\nserialized and written to the errpipe_write fd per subprocess.py.\n\nReturns: the child process's PID.\n\nRaises: Only on an error in the parent process.\n")),
    ("_queue", Some("C implementation of the Python queue module.\nThis module is an implementation detail, please do not use it directly.")),
    ("_queue.Empty", Some("Exception raised by Queue.get(block=0)/get_nowait().")),
    ("_queue.Empty.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_queue.Empty.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_queue.Empty.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_queue.SimpleQueue", Some("Simple, unbounded, reentrant FIFO queue.")),
    ("_queue.SimpleQueue.__class_getitem__", Some("See PEP 585")),
    ("_queue.SimpleQueue.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_queue.SimpleQueue.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_queue.SimpleQueue.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_random", Some("Module implements the Mersenne Twister random number generator.")),
    ("_random.Random", Some("Random() -> create a random number generator with its own internal state.")),
    ("_random.Random.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_random.Random.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_random.Random.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_scproxy._get_proxies", None),
    ("_scproxy._get_proxy_settings", None),
    ("_sha1.SHA1Type.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha1.SHA1Type.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha1.SHA1Type.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha1.sha1", Some("Return a new SHA1 hash object; optionally initialized with a string.")),
    ("_sha256.SHA224Type.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha256.SHA224Type.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha256.SHA224Type.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha256.SHA256Type.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha256.SHA256Type.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha256.SHA256Type.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha256.sha224", Some("Return a new SHA-224 hash object; optionally initialized with a string.")),
    ("_sha256.sha256", Some("Return a new SHA-256 hash object; optionally initialized with a string.")),
    ("_sha3.sha3_224", Some("sha3_224([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 28 bytes.")),
    ("_sha3.sha3_224.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha3.sha3_224.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha3.sha3_224.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha3.sha3_256", Some("sha3_256([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 32 bytes.")),
    ("_sha3.sha3_256.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha3.sha3_256.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha3.sha3_256.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha3.sha3_384", Some("sha3_384([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 48 bytes.")),
    ("_sha3.sha3_384.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha3.sha3_384.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha3.sha3_384.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha3.sha3_512", Some("sha3_512([data], *, usedforsecurity=True) -> SHA3 object\n\nReturn a new SHA3 hash object with a hashbit length of 64 bytes.")),
    ("_sha3.sha3_512.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha3.sha3_512.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha3.sha3_512.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha3.shake_128", Some("shake_128([data], *, usedforsecurity=True) -> SHAKE object\n\nReturn a new SHAKE hash object.")),
    ("_sha3.shake_128.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha3.shake_128.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha3.shake_128.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha3.shake_256", Some("shake_256([data], *, usedforsecurity=True) -> SHAKE object\n\nReturn a new SHAKE hash object.")),
    ("_sha3.shake_256.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha3.shake_256.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha3.shake_256.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha512.SHA384Type.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_sha512.SHA384Type.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_sha512.SHA384Type.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_sha512.sha384", Some("Return a new SHA-384 hash object; optionally initialized with a string.")),
    ("_sha512.sha512", Some("Return a new SHA-512 hash object; optionally initialized with a string.")),
    ("_socket", Some("Implementation module for socket operations.\n\nSee the socket module for documentation.")),
    ("_socket.CMSG_LEN", Some("CMSG_LEN(length) -> control message length\n\nReturn the total length, without trailing padding, of an ancillary\ndata item with associated data of the given length.  This value can\noften be used as the buffer size for recvmsg() to receive a single\nitem of ancillary data, but RFC 3542 requires portable applications to\nuse CMSG_SPACE() and thus include space for padding, even when the\nitem will be the last in the buffer.  Raises OverflowError if length\nis outside the permissible range of values.")),
    ("_socket.CMSG_SPACE", Some("CMSG_SPACE(length) -> buffer size\n\nReturn the buffer size needed for recvmsg() to receive an ancillary\ndata item with associated data of the given length, along with any\ntrailing padding.  The buffer space needed to receive multiple items\nis the sum of the CMSG_SPACE() values for their associated data\nlengths.  Raises OverflowError if length is outside the permissible\nrange of values.")),
    ("_socket.SocketType", Some("socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object\nsocket(family=-1, type=-1, proto=-1, fileno=None) -> socket object\n\nOpen a socket of the given type.  The family argument specifies the\naddress family; it defaults to AF_INET.  The type argument specifies\nwhether this is a stream (SOCK_STREAM, this is the default)\nor datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\nspecifying the default protocol.  Keyword arguments are accepted.\nThe socket is created as non-inheritable.\n\nWhen a fileno is passed in, family, type and proto are auto-detected,\nunless they are explicitly set.\n\nA socket object represents one endpoint of a network connection.\n\nMethods of socket objects (keyword arguments not allowed):\n\n_accept() -- accept connection, returning new socket fd and client address\nbind(addr) -- bind the socket to a local address\nclose() -- close the socket\nconnect(addr) -- connect the socket to a remote address\nconnect_ex(addr) -- connect, return an error code instead of an exception\ndup() -- return a new socket fd duplicated from fileno()\nfileno() -- return underlying file descriptor\ngetpeername() -- return remote address [*]\ngetsockname() -- return local address\ngetsockopt(level, optname[, buflen]) -- get socket options\ngettimeout() -- return timeout or None\nlisten([n]) -- start listening for incoming connections\nrecv(buflen[, flags]) -- receive data\nrecv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\nrecvfrom(buflen[, flags]) -- receive data and sender's address\nrecvfrom_into(buffer[, nbytes, [, flags])\n  -- receive data and sender's address (into a buffer)\nsendall(data[, flags]) -- send all data\nsend(data[, flags]) -- send data, may not send all of it\nsendto(data[, flags], addr) -- send data to a given address\nsetblocking(bool) -- set or clear the blocking I/O flag\ngetblocking() -- return True if socket is blocking, False if non-blocking\nsetsockopt(level, optname, value[, optlen]) -- set socket options\nsettimeout(None | float) -- set or clear the timeout\nshutdown(how) -- shut down traffic in one or both directions\n\n [*] not available on all platforms!")),
    ("_socket.SocketType.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_socket.SocketType.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_socket.SocketType.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_socket.close", Some("close(integer) -> None\n\nClose an integer socket file descriptor.  This is like os.close(), but for\nsockets; on some platforms os.close() won't work for socket file descriptors.")),
    ("_socket.dup", Some("dup(integer) -> integer\n\nDuplicate an integer socket file descriptor.  This is like os.dup(), but for\nsockets; on some platforms os.dup() won't work for socket file descriptors.")),
    ("_socket.getaddrinfo", Some("getaddrinfo(host, port [, family, type, proto, flags])\n    -> list of (family, type, proto, canonname, sockaddr)\n\nResolve host and port into addrinfo struct.")),
    ("_socket.getdefaulttimeout", Some("getdefaulttimeout() -> timeout\n\nReturns the default timeout in seconds (float) for new socket objects.\nA value of None indicates that new socket objects have no timeout.\nWhen the socket module is first imported, the default is None.")),
    ("_socket.gethostbyaddr", Some("gethostbyaddr(host) -> (name, aliaslist, addresslist)\n\nReturn the true host name, a list of aliases, and a list of IP addresses,\nfor a host.  The host argument is a string giving a host name or IP number.")),
    ("_socket.gethostbyname", Some("gethostbyname(host) -> address\n\nReturn the IP address (a string of the form '255.255.255.255') for a host.")),
    ("_socket.gethostbyname_ex", Some("gethostbyname_ex(host) -> (name, aliaslist, addresslist)\n\nReturn the true host name, a list of aliases, and a list of IP addresses,\nfor a host.  The host argument is a string giving a host name or IP number.")),
    ("_socket.gethostname", Some("gethostname() -> string\n\nReturn the current host name.")),
    ("_socket.getnameinfo", Some("getnameinfo(sockaddr, flags) --> (host, port)\n\nGet host and port for a sockaddr.")),
    ("_socket.getprotobyname", Some("getprotobyname(name) -> integer\n\nReturn the protocol number for the named protocol.  (Rarely used.)")),
    ("_socket.getservbyname", Some("getservbyname(servicename[, protocolname]) -> integer\n\nReturn a port number from a service name and protocol name.\nThe optional protocol name, if given, should be 'tcp' or 'udp',\notherwise any protocol will match.")),
    ("_socket.getservbyport", Some("getservbyport(port[, protocolname]) -> string\n\nReturn the service name from a port number and protocol name.\nThe optional protocol name, if given, should be 'tcp' or 'udp',\notherwise any protocol will match.")),
    ("_socket.htonl", Some("htonl(integer) -> integer\n\nConvert a 32-bit integer from host to network byte order.")),
    ("_socket.htons", Some("htons(integer) -> integer\n\nConvert a 16-bit unsigned integer from host to network byte order.")),
    ("_socket.if_indextoname", Some("if_indextoname(if_index)\n\nReturns the interface name corresponding to the interface index if_index.")),
    ("_socket.if_nameindex", Some("if_nameindex()\n\nReturns a list of network interface information (index, name) tuples.")),
    ("_socket.if_nametoindex", Some("if_nametoindex(if_name)\n\nReturns the interface index corresponding to the interface name if_name.")),
    ("_socket.inet_aton", Some("inet_aton(string) -> bytes giving packed 32-bit IP representation\n\nConvert an IP address in string format (123.45.67.89) to the 32-bit packed\nbinary format used in low-level network functions.")),
    ("_socket.inet_ntoa", Some("inet_ntoa(packed_ip) -> ip_address_string\n\nConvert an IP address from 32-bit packed binary format to string format")),
    ("_socket.inet_ntop", Some("inet_ntop(af, packed_ip) -> string formatted IP address\n\nConvert a packed IP address of the given family to string format.")),
    ("_socket.inet_pton", Some("inet_pton(af, ip) -> packed IP address string\n\nConvert an IP address from string format to a packed string suitable\nfor use with low-level network functions.")),
    ("_socket.ntohl", Some("ntohl(integer) -> integer\n\nConvert a 32-bit integer from network to host byte order.")),
    ("_socket.ntohs", Some("ntohs(integer) -> integer\n\nConvert a 16-bit unsigned integer from network to host byte order.")),
    ("_socket.setdefaulttimeout", Some("setdefaulttimeout(timeout)\n\nSet the default timeout in seconds (float) for new socket objects.\nA value of None indicates that new socket objects have no timeout.\nWhen the socket module is first imported, the default is None.")),
    ("_socket.sethostname", Some("sethostname(name)\n\nSets the hostname to name.")),
    ("_socket.socket", Some("socket(family=AF_INET, type=SOCK_STREAM, proto=0) -> socket object\nsocket(family=-1, type=-1, proto=-1, fileno=None) -> socket object\n\nOpen a socket of the given type.  The family argument specifies the\naddress family; it defaults to AF_INET.  The type argument specifies\nwhether this is a stream (SOCK_STREAM, this is the default)\nor datagram (SOCK_DGRAM) socket.  The protocol argument defaults to 0,\nspecifying the default protocol.  Keyword arguments are accepted.\nThe socket is created as non-inheritable.\n\nWhen a fileno is passed in, family, type and proto are auto-detected,\nunless they are explicitly set.\n\nA socket object represents one endpoint of a network connection.\n\nMethods of socket objects (keyword arguments not allowed):\n\n_accept() -- accept connection, returning new socket fd and client address\nbind(addr) -- bind the socket to a local address\nclose() -- close the socket\nconnect(addr) -- connect the socket to a remote address\nconnect_ex(addr) -- connect, return an error code instead of an exception\ndup() -- return a new socket fd duplicated from fileno()\nfileno() -- return underlying file descriptor\ngetpeername() -- return remote address [*]\ngetsockname() -- return local address\ngetsockopt(level, optname[, buflen]) -- get socket options\ngettimeout() -- return timeout or None\nlisten([n]) -- start listening for incoming connections\nrecv(buflen[, flags]) -- receive data\nrecv_into(buffer[, nbytes[, flags]]) -- receive data (into a buffer)\nrecvfrom(buflen[, flags]) -- receive data and sender's address\nrecvfrom_into(buffer[, nbytes, [, flags])\n  -- receive data and sender's address (into a buffer)\nsendall(data[, flags]) -- send all data\nsend(data[, flags]) -- send data, may not send all of it\nsendto(data[, flags], addr) -- send data to a given address\nsetblocking(bool) -- set or clear the blocking I/O flag\ngetblocking() -- return True if socket is blocking, False if non-blocking\nsetsockopt(level, optname, value[, optlen]) -- set socket options\nsettimeout(None | float) -- set or clear the timeout\nshutdown(how) -- shut down traffic in one or both directions\n\n [*] not available on all platforms!")),
    ("_socket.socket.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_socket.socket.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_socket.socket.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_socket.socketpair", Some("socketpair([family[, type [, proto]]]) -> (socket object, socket object)\n\nCreate a pair of socket objects from the sockets returned by the platform\nsocketpair() function.\nThe arguments are the same as for socket() except the default family is\nAF_UNIX if defined on the platform; otherwise, the default is AF_INET.")),
    ("_sqlite3.adapt", Some("Adapt given object to given protocol.")),
    ("_sqlite3.complete_statement", Some("Checks if a string contains a complete SQL statement.")),
    ("_sqlite3.connect", Some("Opens a connection to the SQLite database file database.\n\nYou can use \":memory:\" to open a database connection to a database that resides\nin RAM instead of on disk.")),
    ("_sqlite3.enable_callback_tracebacks", Some("Enable or disable callback functions throwing errors to stderr.")),
    ("_sqlite3.enable_shared_cache", Some("Enable or disable shared cache mode for the calling thread.\n\nThis method is deprecated and will be removed in Python 3.12.\nShared cache is strongly discouraged by the SQLite 3 documentation.\nIf shared cache must be used, open the database in URI mode using\nthe cache=shared query parameter.")),
    ("_sqlite3.register_adapter", Some("Register a function to adapt Python objects to SQLite values.")),
    ("_sqlite3.register_converter", Some("Register a function to convert SQLite values to Python objects.")),
    ("_ssl", Some("Implementation module for SSL socket operations.  See the socket module\nfor documentation.")),
    ("_ssl.Certificate.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_ssl.Certificate.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_ssl.Certificate.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_ssl.MemoryBIO.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_ssl.MemoryBIO.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_ssl.MemoryBIO.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_ssl.RAND_add", Some("Mix string into the OpenSSL PRNG state.\n\nentropy (a float) is a lower bound on the entropy contained in\nstring.  See RFC 4086.")),
    ("_ssl.RAND_bytes", Some("Generate n cryptographically strong pseudo-random bytes.")),
    ("_ssl.RAND_pseudo_bytes", Some("Generate n pseudo-random bytes.\n\nReturn a pair (bytes, is_cryptographic).  is_cryptographic is True\nif the bytes generated are cryptographically strong.")),
    ("_ssl.RAND_status", Some("Returns True if the OpenSSL PRNG has been seeded with enough data and False if not.\n\nIt is necessary to seed the PRNG with RAND_add() on some platforms before\nusing the ssl() function.")),
    ("_ssl.SSLSession.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_ssl.SSLSession.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_ssl.SSLSession.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_ssl._SSLContext.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_ssl._SSLContext.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_ssl._SSLContext.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_ssl._SSLSocket.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_ssl._SSLSocket.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_ssl._SSLSocket.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_ssl._test_decode_cert", None),
    ("_ssl.get_default_verify_paths", Some("Return search paths and environment vars that are used by SSLContext's set_default_verify_paths() to load default CAs.\n\nThe values are 'cert_file_env', 'cert_file', 'cert_dir_env', 'cert_dir'.")),
    ("_ssl.nid2obj", Some("Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.")),
    ("_ssl.txt2obj", Some("Lookup NID, short name, long name and OID of an ASN1_OBJECT.\n\nBy default objects are looked up by OID. With name=True short and\nlong name are also matched.")),
    ("_statistics", Some("Accelerators for the statistics module.\n")),
    ("_statistics._normal_dist_inv_cdf", None),
    ("_struct", Some("Functions to convert between Python values and C structs.\nPython bytes objects are used to hold the data representing the C struct\nand also as format strings (explained below) to describe the layout of data\nin the C struct.\n\nThe optional first format char indicates byte order, size and alignment:\n  @: native order, size & alignment (default)\n  =: native order, std. size & alignment\n  <: little-endian, std. size & alignment\n  >: big-endian, std. size & alignment\n  !: same as >\n\nThe remaining chars indicate types of args and must match exactly;\nthese can be preceded by a decimal repeat count:\n  x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;\n  ?: _Bool (requires C99; if not available, char is used instead)\n  h:short; H:unsigned short; i:int; I:unsigned int;\n  l:long; L:unsigned long; f:float; d:double; e:half-float.\nSpecial cases (preceding decimal count indicates length):\n  s:string (array of char); p: pascal string (with count byte).\nSpecial cases (only available in native format):\n  n:ssize_t; N:size_t;\n  P:an integer type that is wide enough to hold a pointer.\nSpecial case (not in native mode unless 'long long' in platform C):\n  q:long long; Q:unsigned long long\nWhitespace between formats is ignored.\n\nThe variable struct.error is an exception raised on errors.\n")),
    ("_struct.Struct", Some("Struct(fmt) --> compiled struct object\n\n")),
    ("_struct.Struct.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("_struct.Struct.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("_struct.Struct.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("_struct._clearcache", Some("Clear the internal cache.")),
    ("_struct.calcsize", Some("Return size in bytes of the struct described by the format string.")),
    ("_struct.iter_unpack", Some("Return an iterator yielding tuples unpacked from the given bytes.\n\nThe bytes are unpacked according to the format string, like\na repeated invocation of unpack_from().\n\nRequires that the bytes length be a multiple of the format struct size.")),
    ("_struct.pack", Some("pack(format, v1, v2, ...) -> bytes\n\nReturn a bytes object containing the values v1, v2, ... packed according\nto the format string.  See help(struct) for more on format strings.")),
    ("_struct.pack_into", Some("pack_into(format, buffer, offset, v1, v2, ...)\n\nPack the values v1, v2, ... according to the format string and write\nthe packed bytes into the writable buffer buf starting at offset.  Note\nthat the offset is a required argument.  See help(struct) for more\non format strings.")),
    ("_struct.unpack", Some("Return a tuple containing values unpacked according to the format string.\n\nThe buffer's size in bytes must be calcsize(format).\n\nSee help(struct) for more on format strings.")),
    ("_struct.unpack_from", Some("Return a tuple containing values unpacked according to the format string.\n\nThe buffer's size, minus offset, must be at least calcsize(format).\n\nSee help(struct) for more on format strings.")),
    ("_typing", Some("Accelerators for the typing module.\n")),
    ("_typing._idfunc", None),
    ("_uuid.generate_time_safe", None),
    ("array", Some("This module defines an object type which can efficiently represent\nan array of basic values: characters, integers, floating point\nnumbers.  Arrays are sequence types and behave very much like lists,\nexcept that the type of objects stored in them is constrained.\n")),
    ("array.ArrayType", Some("array(typecode [, initializer]) -> array\n\nReturn a new array whose items are restricted by typecode, and\ninitialized from the optional initializer value, which must be a list,\nstring or iterable over elements of the appropriate type.\n\nArrays represent basic values and behave very much like lists, except\nthe type of objects stored in them is constrained. The type is specified\nat object creation time by using a type code, which is a single character.\nThe following type codes are defined:\n\n    Type code   C Type             Minimum size in bytes\n    'b'         signed integer     1\n    'B'         unsigned integer   1\n    'u'         Unicode character  2 (see note)\n    'h'         signed integer     2\n    'H'         unsigned integer   2\n    'i'         signed integer     2\n    'I'         unsigned integer   2\n    'l'         signed integer     4\n    'L'         unsigned integer   4\n    'q'         signed integer     8 (see note)\n    'Q'         unsigned integer   8 (see note)\n    'f'         floating point     4\n    'd'         floating point     8\n\nNOTE: The 'u' typecode corresponds to Python's unicode character. On\nnarrow builds this is 2-bytes on wide builds this is 4-bytes.\n\nNOTE: The 'q' and 'Q' type codes are only available if the platform\nC compiler used to build Python supports 'long long', or, on Windows,\n'__int64'.\n\nMethods:\n\nappend() -- append a new item to the end of the array\nbuffer_info() -- return information giving the current memory info\nbyteswap() -- byteswap all the items of the array\ncount() -- return number of occurrences of an object\nextend() -- extend array by appending multiple elements from an iterable\nfromfile() -- read items from a file object\nfromlist() -- append items from the list\nfrombytes() -- append items from the string\nindex() -- return index of first occurrence of an object\ninsert() -- insert a new item into the array at a provided position\npop() -- remove and return item (default last)\nremove() -- remove first occurrence of an object\nreverse() -- reverse the order of the items in the array\ntofile() -- write all items to a file object\ntolist() -- return the array converted to an ordinary list\ntobytes() -- return the array converted to a string\n\nAttributes:\n\ntypecode -- the typecode character used to create the array\nitemsize -- the length in bytes of one array item\n")),
    ("array.ArrayType.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("array.ArrayType.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("array.ArrayType.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("array._array_reconstructor", Some("Internal. Used for pickling support.")),
    ("array.array", Some("array(typecode [, initializer]) -> array\n\nReturn a new array whose items are restricted by typecode, and\ninitialized from the optional initializer value, which must be a list,\nstring or iterable over elements of the appropriate type.\n\nArrays represent basic values and behave very much like lists, except\nthe type of objects stored in them is constrained. The type is specified\nat object creation time by using a type code, which is a single character.\nThe following type codes are defined:\n\n    Type code   C Type             Minimum size in bytes\n    'b'         signed integer     1\n    'B'         unsigned integer   1\n    'u'         Unicode character  2 (see note)\n    'h'         signed integer     2\n    'H'         unsigned integer   2\n    'i'         signed integer     2\n    'I'         unsigned integer   2\n    'l'         signed integer     4\n    'L'         unsigned integer   4\n    'q'         signed integer     8 (see note)\n    'Q'         unsigned integer   8 (see note)\n    'f'         floating point     4\n    'd'         floating point     8\n\nNOTE: The 'u' typecode corresponds to Python's unicode character. On\nnarrow builds this is 2-bytes on wide builds this is 4-bytes.\n\nNOTE: The 'q' and 'Q' type codes are only available if the platform\nC compiler used to build Python supports 'long long', or, on Windows,\n'__int64'.\n\nMethods:\n\nappend() -- append a new item to the end of the array\nbuffer_info() -- return information giving the current memory info\nbyteswap() -- byteswap all the items of the array\ncount() -- return number of occurrences of an object\nextend() -- extend array by appending multiple elements from an iterable\nfromfile() -- read items from a file object\nfromlist() -- append items from the list\nfrombytes() -- append items from the string\nindex() -- return index of first occurrence of an object\ninsert() -- insert a new item into the array at a provided position\npop() -- remove and return item (default last)\nremove() -- remove first occurrence of an object\nreverse() -- reverse the order of the items in the array\ntofile() -- write all items to a file object\ntolist() -- return the array converted to an ordinary list\ntobytes() -- return the array converted to a string\n\nAttributes:\n\ntypecode -- the typecode character used to create the array\nitemsize -- the length in bytes of one array item\n")),
    ("array.array.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("array.array.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("array.array.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("binascii", Some("Conversion between binary data and ASCII")),
    ("binascii.Error.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("binascii.Error.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("binascii.Error.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("binascii.Incomplete.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("binascii.Incomplete.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("binascii.Incomplete.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("binascii.a2b_base64", Some("Decode a line of base64 data.\n\n  strict_mode\n    When set to True, bytes that are not part of the base64 standard are not allowed.\n    The same applies to excess data after padding (= / ==).")),
    ("binascii.a2b_hex", Some("Binary data of hexadecimal representation.\n\nhexstr must contain an even number of hex digits (upper or lower case).\nThis function is also available as \"unhexlify()\".")),
    ("binascii.a2b_qp", Some("Decode a string of qp-encoded data.")),
    ("binascii.a2b_uu", Some("Decode a line of uuencoded data.")),
    ("binascii.b2a_base64", Some("Base64-code line of data.")),
    ("binascii.b2a_hex", Some("Hexadecimal representation of binary data.\n\n  sep\n    An optional single character or byte to separate hex bytes.\n  bytes_per_sep\n    How many bytes between separators.  Positive values count from the\n    right, negative values count from the left.\n\nThe return value is a bytes object.  This function is also\navailable as \"hexlify()\".\n\nExample:\n>>> binascii.b2a_hex(b'\\xb9\\x01\\xef')\nb'b901ef'\n>>> binascii.hexlify(b'\\xb9\\x01\\xef', ':')\nb'b9:01:ef'\n>>> binascii.b2a_hex(b'\\xb9\\x01\\xef', b'_', 2)\nb'b9_01ef'")),
    ("binascii.b2a_qp", Some("Encode a string using quoted-printable encoding.\n\nOn encoding, when istext is set, newlines are not encoded, and white\nspace at end of lines is.  When istext is not set, \\r and \\n (CR/LF)\nare both encoded.  When quotetabs is set, space and tabs are encoded.")),
    ("binascii.b2a_uu", Some("Uuencode line of data.")),
    ("binascii.crc32", Some("Compute CRC-32 incrementally.")),
    ("binascii.crc_hqx", Some("Compute CRC-CCITT incrementally.")),
    ("binascii.hexlify", Some("Hexadecimal representation of binary data.\n\n  sep\n    An optional single character or byte to separate hex bytes.\n  bytes_per_sep\n    How many bytes between separators.  Positive values count from the\n    right, negative values count from the left.\n\nThe return value is a bytes object.  This function is also\navailable as \"b2a_hex()\".")),
    ("binascii.unhexlify", Some("Binary data of hexadecimal representation.\n\nhexstr must contain an even number of hex digits (upper or lower case).")),
    ("cmath", Some("This module provides access to mathematical functions for complex\nnumbers.")),
    ("cmath.acos", Some("Return the arc cosine of z.")),
    ("cmath.acosh", Some("Return the inverse hyperbolic cosine of z.")),
    ("cmath.asin", Some("Return the arc sine of z.")),
    ("cmath.asinh", Some("Return the inverse hyperbolic sine of z.")),
    ("cmath.atan", Some("Return the arc tangent of z.")),
    ("cmath.atanh", Some("Return the inverse hyperbolic tangent of z.")),
    ("cmath.cos", Some("Return the cosine of z.")),
    ("cmath.cosh", Some("Return the hyperbolic cosine of z.")),
    ("cmath.exp", Some("Return the exponential value e**z.")),
    ("cmath.isclose", Some("Determine whether two complex numbers are close in value.\n\n  rel_tol\n    maximum difference for being considered \"close\", relative to the\n    magnitude of the input values\n  abs_tol\n    maximum difference for being considered \"close\", regardless of the\n    magnitude of the input values\n\nReturn True if a is close in value to b, and False otherwise.\n\nFor the values to be considered close, the difference between them must be\nsmaller than at least one of the tolerances.\n\n-inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is\nnot close to anything, even itself. inf and -inf are only close to themselves.")),
    ("cmath.isfinite", Some("Return True if both the real and imaginary parts of z are finite, else False.")),
    ("cmath.isinf", Some("Checks if the real or imaginary part of z is infinite.")),
    ("cmath.isnan", Some("Checks if the real or imaginary part of z not a number (NaN).")),
    ("cmath.log", Some("log(z[, base]) -> the logarithm of z to the given base.\n\nIf the base is not specified, returns the natural logarithm (base e) of z.")),
    ("cmath.log10", Some("Return the base-10 logarithm of z.")),
    ("cmath.phase", Some("Return argument, also known as the phase angle, of a complex.")),
    ("cmath.polar", Some("Convert a complex from rectangular coordinates to polar coordinates.\n\nr is the distance from 0 and phi the phase angle.")),
    ("cmath.rect", Some("Convert from polar coordinates to rectangular coordinates.")),
    ("cmath.sin", Some("Return the sine of z.")),
    ("cmath.sinh", Some("Return the hyperbolic sine of z.")),
    ("cmath.sqrt", Some("Return the square root of z.")),
    ("cmath.tan", Some("Return the tangent of z.")),
    ("cmath.tanh", Some("Return the hyperbolic tangent of z.")),
    ("fcntl", Some("This module performs file control and I/O control on file\ndescriptors.  It is an interface to the fcntl() and ioctl() Unix\nroutines.  File descriptors can be obtained with the fileno() method of\na file or socket object.")),
    ("fcntl.fcntl", Some("Perform the operation `cmd` on file descriptor fd.\n\nThe values used for `cmd` are operating system dependent, and are available\nas constants in the fcntl module, using the same names as used in\nthe relevant C header files.  The argument arg is optional, and\ndefaults to 0; it may be an int or a string.  If arg is given as a string,\nthe return value of fcntl is a string of that length, containing the\nresulting value put in the arg buffer by the operating system.  The length\nof the arg string is not allowed to exceed 1024 bytes.  If the arg given\nis an integer or if none is specified, the result value is an integer\ncorresponding to the return value of the fcntl call in the C code.")),
    ("fcntl.flock", Some("Perform the lock operation `operation` on file descriptor `fd`.\n\nSee the Unix manual page for flock(2) for details (On some systems, this\nfunction is emulated using fcntl()).")),
    ("fcntl.ioctl", Some("Perform the operation `request` on file descriptor `fd`.\n\nThe values used for `request` are operating system dependent, and are available\nas constants in the fcntl or termios library modules, using the same names as\nused in the relevant C header files.\n\nThe argument `arg` is optional, and defaults to 0; it may be an int or a\nbuffer containing character data (most likely a string or an array).\n\nIf the argument is a mutable buffer (such as an array) and if the\nmutate_flag argument (which is only allowed in this case) is true then the\nbuffer is (in effect) passed to the operating system and changes made by\nthe OS will be reflected in the contents of the buffer after the call has\nreturned.  The return value is the integer returned by the ioctl system\ncall.\n\nIf the argument is a mutable buffer and the mutable_flag argument is false,\nthe behavior is as if a string had been passed.\n\nIf the argument is an immutable buffer (most likely a string) then a copy\nof the buffer is passed to the operating system and the return value is a\nstring of the same length containing whatever the operating system put in\nthe buffer.  The length of the arg buffer in this case is not allowed to\nexceed 1024 bytes.\n\nIf the arg given is an integer or if none is specified, the result value is\nan integer corresponding to the return value of the ioctl call in the C\ncode.")),
    ("fcntl.lockf", Some("A wrapper around the fcntl() locking calls.\n\n`fd` is the file descriptor of the file to lock or unlock, and operation is one\nof the following values:\n\n    LOCK_UN - unlock\n    LOCK_SH - acquire a shared lock\n    LOCK_EX - acquire an exclusive lock\n\nWhen operation is LOCK_SH or LOCK_EX, it can also be bitwise ORed with\nLOCK_NB to avoid blocking on lock acquisition.  If LOCK_NB is used and the\nlock cannot be acquired, an OSError will be raised and the exception will\nhave an errno attribute set to EACCES or EAGAIN (depending on the operating\nsystem -- for portability, check for either value).\n\n`len` is the number of bytes to lock, with the default meaning to lock to\nEOF.  `start` is the byte offset, relative to `whence`, to that the lock\nstarts.  `whence` is as with fileobj.seek(), specifically:\n\n    0 - relative to the start of the file (SEEK_SET)\n    1 - relative to the current buffer position (SEEK_CUR)\n    2 - relative to the end of the file (SEEK_END)")),
    ("grp", Some("Access to the Unix group database.\n\nGroup entries are reported as 4-tuples containing the following fields\nfrom the group database, in order:\n\n  gr_name   - name of the group\n  gr_passwd - group password (encrypted); often empty\n  gr_gid    - numeric ID of the group\n  gr_mem    - list of members\n\nThe gid is an integer, name and password are strings.  (Note that most\nusers are not explicitly listed as members of the groups they are in\naccording to the password database.  Check both databases to get\ncomplete membership information.)")),
    ("grp.getgrall", Some("Return a list of all available group entries, in arbitrary order.\n\nAn entry whose name starts with '+' or '-' represents an instruction\nto use YP/NIS and may not be accessible via getgrnam or getgrgid.")),
    ("grp.getgrgid", Some("Return the group database entry for the given numeric group ID.\n\nIf id is not valid, raise KeyError.")),
    ("grp.getgrnam", Some("Return the group database entry for the given group name.\n\nIf name is not valid, raise KeyError.")),
    ("grp.struct_group", Some("grp.struct_group: Results from getgr*() routines.\n\nThis object may be accessed either as a tuple of\n  (gr_name,gr_passwd,gr_gid,gr_mem)\nor via the object attributes as named in the above tuple.\n")),
    ("grp.struct_group.__class_getitem__", Some("See PEP 585")),
    ("grp.struct_group.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("grp.struct_group.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("grp.struct_group.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("math", Some("This module provides access to the mathematical functions\ndefined by the C standard.")),
    ("math.acos", Some("Return the arc cosine (measured in radians) of x.\n\nThe result is between 0 and pi.")),
    ("math.acosh", Some("Return the inverse hyperbolic cosine of x.")),
    ("math.asin", Some("Return the arc sine (measured in radians) of x.\n\nThe result is between -pi/2 and pi/2.")),
    ("math.asinh", Some("Return the inverse hyperbolic sine of x.")),
    ("math.atan", Some("Return the arc tangent (measured in radians) of x.\n\nThe result is between -pi/2 and pi/2.")),
    ("math.atan2", Some("Return the arc tangent (measured in radians) of y/x.\n\nUnlike atan(y/x), the signs of both x and y are considered.")),
    ("math.atanh", Some("Return the inverse hyperbolic tangent of x.")),
    ("math.cbrt", Some("Return the cube root of x.")),
    ("math.ceil", Some("Return the ceiling of x as an Integral.\n\nThis is the smallest integer >= x.")),
    ("math.comb", Some("Number of ways to choose k items from n items without repetition and without order.\n\nEvaluates to n! / (k! * (n - k)!) when k <= n and evaluates\nto zero when k > n.\n\nAlso called the binomial coefficient because it is equivalent\nto the coefficient of k-th term in polynomial expansion of the\nexpression (1 + x)**n.\n\nRaises TypeError if either of the arguments are not integers.\nRaises ValueError if either of the arguments are negative.")),
    ("math.copysign", Some("Return a float with the magnitude (absolute value) of x but the sign of y.\n\nOn platforms that support signed zeros, copysign(1.0, -0.0)\nreturns -1.0.\n")),
    ("math.cos", Some("Return the cosine of x (measured in radians).")),
    ("math.cosh", Some("Return the hyperbolic cosine of x.")),
    ("math.degrees", Some("Convert angle x from radians to degrees.")),
    ("math.dist", Some("Return the Euclidean distance between two points p and q.\n\nThe points should be specified as sequences (or iterables) of\ncoordinates.  Both inputs must have the same dimension.\n\nRoughly equivalent to:\n    sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))")),
    ("math.erf", Some("Error function at x.")),
    ("math.erfc", Some("Complementary error function at x.")),
    ("math.exp", Some("Return e raised to the power of x.")),
    ("math.exp2", Some("Return 2 raised to the power of x.")),
    ("math.expm1", Some("Return exp(x)-1.\n\nThis function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.")),
    ("math.fabs", Some("Return the absolute value of the float x.")),
    ("math.factorial", Some("Find n!.\n\nRaise a ValueError if x is negative or non-integral.")),
    ("math.floor", Some("Return the floor of x as an Integral.\n\nThis is the largest integer <= x.")),
    ("math.fmod", Some("Return fmod(x, y), according to platform C.\n\nx % y may differ.")),
    ("math.frexp", Some("Return the mantissa and exponent of x, as pair (m, e).\n\nm is a float and e is an int, such that x = m * 2.**e.\nIf x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.")),
    ("math.fsum", Some("Return an accurate floating point sum of values in the iterable seq.\n\nAssumes IEEE-754 floating point arithmetic.")),
    ("math.gamma", Some("Gamma function at x.")),
    ("math.gcd", Some("Greatest Common Divisor.")),
    ("math.hypot", Some("hypot(*coordinates) -> value\n\nMultidimensional Euclidean distance from the origin to a point.\n\nRoughly equivalent to:\n    sqrt(sum(x**2 for x in coordinates))\n\nFor a two dimensional point (x, y), gives the hypotenuse\nusing the Pythagorean theorem:  sqrt(x*x + y*y).\n\nFor example, the hypotenuse of a 3/4/5 right triangle is:\n\n    >>> hypot(3.0, 4.0)\n    5.0\n")),
    ("math.isclose", Some("Determine whether two floating point numbers are close in value.\n\n  rel_tol\n    maximum difference for being considered \"close\", relative to the\n    magnitude of the input values\n  abs_tol\n    maximum difference for being considered \"close\", regardless of the\n    magnitude of the input values\n\nReturn True if a is close in value to b, and False otherwise.\n\nFor the values to be considered close, the difference between them\nmust be smaller than at least one of the tolerances.\n\n-inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\nis, NaN is not close to anything, even itself.  inf and -inf are\nonly close to themselves.")),
    ("math.isfinite", Some("Return True if x is neither an infinity nor a NaN, and False otherwise.")),
    ("math.isinf", Some("Return True if x is a positive or negative infinity, and False otherwise.")),
    ("math.isnan", Some("Return True if x is a NaN (not a number), and False otherwise.")),
    ("math.isqrt", Some("Return the integer part of the square root of the input.")),
    ("math.lcm", Some("Least Common Multiple.")),
    ("math.ldexp", Some("Return x * (2**i).\n\nThis is essentially the inverse of frexp().")),
    ("math.lgamma", Some("Natural logarithm of absolute value of Gamma function at x.")),
    ("math.log", Some("log(x, [base=math.e])\nReturn the logarithm of x to the given base.\n\nIf the base not specified, returns the natural logarithm (base e) of x.")),
    ("math.log10", Some("Return the base 10 logarithm of x.")),
    ("math.log1p", Some("Return the natural logarithm of 1+x (base e).\n\nThe result is computed in a way which is accurate for x near zero.")),
    ("math.log2", Some("Return the base 2 logarithm of x.")),
    ("math.modf", Some("Return the fractional and integer parts of x.\n\nBoth results carry the sign of x and are floats.")),
    ("math.nextafter", Some("Return the next floating-point value after x towards y.")),
    ("math.perm", Some("Number of ways to choose k items from n items without repetition and with order.\n\nEvaluates to n! / (n - k)! when k <= n and evaluates\nto zero when k > n.\n\nIf k is not specified or is None, then k defaults to n\nand the function returns n!.\n\nRaises TypeError if either of the arguments are not integers.\nRaises ValueError if either of the arguments are negative.")),
    ("math.pow", Some("Return x**y (x to the power of y).")),
    ("math.prod", Some("Calculate the product of all the elements in the input iterable.\n\nThe default start value for the product is 1.\n\nWhen the iterable is empty, return the start value.  This function is\nintended specifically for use with numeric values and may reject\nnon-numeric types.")),
    ("math.radians", Some("Convert angle x from degrees to radians.")),
    ("math.remainder", Some("Difference between x and the closest integer multiple of y.\n\nReturn x - n*y where n*y is the closest integer multiple of y.\nIn the case where x is exactly halfway between two multiples of\ny, the nearest even value of n is used. The result is always exact.")),
    ("math.sin", Some("Return the sine of x (measured in radians).")),
    ("math.sinh", Some("Return the hyperbolic sine of x.")),
    ("math.sqrt", Some("Return the square root of x.")),
    ("math.tan", Some("Return the tangent of x (measured in radians).")),
    ("math.tanh", Some("Return the hyperbolic tangent of x.")),
    ("math.trunc", Some("Truncates the Real x to the nearest Integral toward 0.\n\nUses the __trunc__ magic method.")),
    ("math.ulp", Some("Return the value of the least significant bit of the float x.")),
    ("mmap.mmap", Some("Windows: mmap(fileno, length[, tagname[, access[, offset]]])\n\nMaps length bytes from the file specified by the file handle fileno,\nand returns a mmap object.  If length is larger than the current size\nof the file, the file is extended to contain length bytes.  If length\nis 0, the maximum length of the map is the current size of the file,\nexcept that if the file is empty Windows raises an exception (you cannot\ncreate an empty mapping on Windows).\n\nUnix: mmap(fileno, length[, flags[, prot[, access[, offset]]]])\n\nMaps length bytes from the file specified by the file descriptor fileno,\nand returns a mmap object.  If length is 0, the maximum length of the map\nwill be the current size of the file when mmap is called.\nflags specifies the nature of the mapping. MAP_PRIVATE creates a\nprivate copy-on-write mapping, so changes to the contents of the mmap\nobject will be private to this process, and MAP_SHARED creates a mapping\nthat's shared with all other processes mapping the same areas of the file.\nThe default value is MAP_SHARED.\n\nTo map anonymous memory, pass -1 as the fileno (both versions).")),
    ("mmap.mmap.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("mmap.mmap.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("mmap.mmap.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("pyexpat", Some("Python wrapper for Expat parser.")),
    ("pyexpat.ErrorString", Some("Returns string error for given number.")),
    ("pyexpat.ParserCreate", Some("Return a new XML parser object.")),
    ("pyexpat.XMLParserType", Some("XML parser")),
    ("pyexpat.XMLParserType.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("pyexpat.XMLParserType.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("pyexpat.XMLParserType.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("resource.getpagesize", None),
    ("resource.getrlimit", None),
    ("resource.getrusage", None),
    ("resource.setrlimit", None),
    ("resource.struct_rusage", Some("struct_rusage: Result from getrusage.\n\nThis object may be accessed either as a tuple of\n    (utime,stime,maxrss,ixrss,idrss,isrss,minflt,majflt,\n    nswap,inblock,oublock,msgsnd,msgrcv,nsignals,nvcsw,nivcsw)\nor via the attributes ru_utime, ru_stime, ru_maxrss, and so on.")),
    ("resource.struct_rusage.__class_getitem__", Some("See PEP 585")),
    ("resource.struct_rusage.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("resource.struct_rusage.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("resource.struct_rusage.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("select", Some("This module supports asynchronous I/O on multiple file descriptors.\n\n*** IMPORTANT NOTICE ***\nOn Windows, only sockets are supported; on Unix, all file descriptors.")),
    ("select.kevent", Some("kevent(ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=0)\n\nThis object is the equivalent of the struct kevent for the C API.\n\nSee the kqueue manpage for more detailed information about the meaning\nof the arguments.\n\nOne minor note: while you might hope that udata could store a\nreference to a python object, it cannot, because it is impossible to\nkeep a proper reference count of the object once it's passed into the\nkernel. Therefore, I have restricted it to only storing an integer.  I\nrecommend ignoring it and simply using the 'ident' field to key off\nof. You could also set up a dictionary on the python side to store a\nudata->object mapping.")),
    ("select.kevent.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("select.kevent.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("select.kevent.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("select.kqueue", Some("Kqueue syscall wrapper.\n\nFor example, to start watching a socket for input:\n>>> kq = kqueue()\n>>> sock = socket()\n>>> sock.connect((host, port))\n>>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_ADD)], 0)\n\nTo wait one second for it to become writeable:\n>>> kq.control(None, 1, 1000)\n\nTo stop listening:\n>>> kq.control([kevent(sock, KQ_FILTER_WRITE, KQ_EV_DELETE)], 0)")),
    ("select.kqueue.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("select.kqueue.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("select.kqueue.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("select.kqueue.fromfd", Some("Create a kqueue object from a given control fd.")),
    ("select.poll", Some("Returns a polling object.\n\nThis object supports registering and unregistering file descriptors, and then\npolling them for I/O events.")),
    ("select.select", Some("Wait until one or more file descriptors are ready for some kind of I/O.\n\nThe first three arguments are iterables of file descriptors to be waited for:\nrlist -- wait until ready for reading\nwlist -- wait until ready for writing\nxlist -- wait for an \"exceptional condition\"\nIf only one kind of condition is required, pass [] for the other lists.\n\nA file descriptor is either a socket or file object, or a small integer\ngotten from a fileno() method call on one of those.\n\nThe optional 4th argument specifies a timeout in seconds; it may be\na floating point number to specify fractions of seconds.  If it is absent\nor None, the call will never time out.\n\nThe return value is a tuple of three lists corresponding to the first three\narguments; each contains the subset of the corresponding file descriptors\nthat are ready.\n\n*** IMPORTANT NOTICE ***\nOn Windows, only sockets are supported; on Unix, all file\ndescriptors can be used.")),
    ("syslog.LOG_MASK", None),
    ("syslog.LOG_UPTO", None),
    ("syslog.closelog", None),
    ("syslog.openlog", None),
    ("syslog.setlogmask", None),
    ("syslog.syslog", None),
    ("termios", Some("This module provides an interface to the Posix calls for tty I/O control.\nFor a complete description of these calls, see the Posix or Unix manual\npages. It is only available for those Unix versions that support Posix\ntermios style tty I/O control.\n\nAll functions in this module take a file descriptor fd as their first\nargument. This can be an integer file descriptor, such as returned by\nsys.stdin.fileno(), or a file object, such as sys.stdin itself.")),
    ("termios.error.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("termios.error.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("termios.error.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("termios.tcdrain", Some("Wait until all output written to file descriptor fd has been transmitted.")),
    ("termios.tcflow", Some("Suspend or resume input or output on file descriptor fd.\n\nThe action argument can be termios.TCOOFF to suspend output,\ntermios.TCOON to restart output, termios.TCIOFF to suspend input,\nor termios.TCION to restart input.")),
    ("termios.tcflush", Some("Discard queued data on file descriptor fd.\n\nThe queue selector specifies which queue: termios.TCIFLUSH for the input\nqueue, termios.TCOFLUSH for the output queue, or termios.TCIOFLUSH for\nboth queues.")),
    ("termios.tcgetattr", Some("Get the tty attributes for file descriptor fd.\n\nReturns a list [iflag, oflag, cflag, lflag, ispeed, ospeed, cc]\nwhere cc is a list of the tty special characters (each a string of\nlength 1, except the items with indices VMIN and VTIME, which are\nintegers when these fields are defined).  The interpretation of the\nflags and the speeds as well as the indexing in the cc array must be\ndone using the symbolic constants defined in this module.")),
    ("termios.tcgetwinsize", Some("Get the tty winsize for file descriptor fd.\n\nReturns a tuple (ws_row, ws_col).")),
    ("termios.tcsendbreak", Some("Send a break on file descriptor fd.\n\nA zero duration sends a break for 0.25-0.5 seconds; a nonzero duration\nhas a system dependent meaning.")),
    ("termios.tcsetattr", Some("Set the tty attributes for file descriptor fd.\n\nThe attributes to be set are taken from the attributes argument, which\nis a list like the one returned by tcgetattr(). The when argument\ndetermines when the attributes are changed: termios.TCSANOW to\nchange immediately, termios.TCSADRAIN to change after transmitting all\nqueued output, or termios.TCSAFLUSH to change after transmitting all\nqueued output and discarding all queued input.")),
    ("termios.tcsetwinsize", Some("Set the tty winsize for file descriptor fd.\n\nThe winsize to be set is taken from the winsize argument, which\nis a two-item tuple (ws_row, ws_col) like the one returned by tcgetwinsize().")),
    ("unicodedata", Some("This module provides access to the Unicode Character Database which\ndefines character properties for all Unicode characters. The data in\nthis database is based on the UnicodeData.txt file version\n14.0.0 which is publicly available from ftp://ftp.unicode.org/.\n\nThe module uses the same names and symbols as defined by the\nUnicodeData File Format 14.0.0.")),
    ("unicodedata.UCD.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("unicodedata.UCD.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("unicodedata.UCD.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("unicodedata.bidirectional", Some("Returns the bidirectional class assigned to the character chr as string.\n\nIf no such value is defined, an empty string is returned.")),
    ("unicodedata.category", Some("Returns the general category assigned to the character chr as string.")),
    ("unicodedata.combining", Some("Returns the canonical combining class assigned to the character chr as integer.\n\nReturns 0 if no combining class is defined.")),
    ("unicodedata.decimal", Some("Converts a Unicode character into its equivalent decimal value.\n\nReturns the decimal value assigned to the character chr as integer.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.")),
    ("unicodedata.decomposition", Some("Returns the character decomposition mapping assigned to the character chr as string.\n\nAn empty string is returned in case no such mapping is defined.")),
    ("unicodedata.digit", Some("Converts a Unicode character into its equivalent digit value.\n\nReturns the digit value assigned to the character chr as integer.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.")),
    ("unicodedata.east_asian_width", Some("Returns the east asian width assigned to the character chr as string.")),
    ("unicodedata.is_normalized", Some("Return whether the Unicode string unistr is in the normal form 'form'.\n\nValid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'.")),
    ("unicodedata.lookup", Some("Look up character by name.\n\nIf a character with the given name is found, return the\ncorresponding character.  If not found, KeyError is raised.")),
    ("unicodedata.mirrored", Some("Returns the mirrored property assigned to the character chr as integer.\n\nReturns 1 if the character has been identified as a \"mirrored\"\ncharacter in bidirectional text, 0 otherwise.")),
    ("unicodedata.name", Some("Returns the name assigned to the character chr as a string.\n\nIf no name is defined, default is returned, or, if not given,\nValueError is raised.")),
    ("unicodedata.normalize", Some("Return the normal form 'form' for the Unicode string unistr.\n\nValid values for form are 'NFC', 'NFKC', 'NFD', and 'NFKD'.")),
    ("unicodedata.numeric", Some("Converts a Unicode character into its equivalent numeric value.\n\nReturns the numeric value assigned to the character chr as float.\nIf no such value is defined, default is returned, or, if not given,\nValueError is raised.")),
    ("zlib", Some("The functions in this module allow compression and decompression using the\nzlib library, which is based on GNU zip.\n\nadler32(string[, start]) -- Compute an Adler-32 checksum.\ncompress(data[, level]) -- Compress data, with compression level 0-9 or -1.\ncompressobj([level[, ...]]) -- Return a compressor object.\ncrc32(string[, start]) -- Compute a CRC-32 checksum.\ndecompress(string,[wbits],[bufsize]) -- Decompresses a compressed string.\ndecompressobj([wbits[, zdict]]) -- Return a decompressor object.\n\n'wbits' is window buffer size and container format.\nCompressor objects support compress() and flush() methods; decompressor\nobjects support decompress() and flush().")),
    ("zlib.adler32", Some("Compute an Adler-32 checksum of data.\n\n  value\n    Starting value of the checksum.\n\nThe returned checksum is an integer.")),
    ("zlib.compress", Some("Returns a bytes object containing compressed data.\n\n  data\n    Binary data to be compressed.\n  level\n    Compression level, in 0-9 or -1.\n  wbits\n    The window buffer size and container format.")),
    ("zlib.compressobj", Some("Return a compressor object.\n\n  level\n    The compression level (an integer in the range 0-9 or -1; default is\n    currently equivalent to 6).  Higher compression levels are slower,\n    but produce smaller results.\n  method\n    The compression algorithm.  If given, this must be DEFLATED.\n  wbits\n    +9 to +15: The base-two logarithm of the window size.  Include a zlib\n        container.\n    -9 to -15: Generate a raw stream.\n    +25 to +31: Include a gzip container.\n  memLevel\n    Controls the amount of memory used for internal compression state.\n    Valid values range from 1 to 9.  Higher values result in higher memory\n    usage, faster compression, and smaller output.\n  strategy\n    Used to tune the compression algorithm.  Possible values are\n    Z_DEFAULT_STRATEGY, Z_FILTERED, and Z_HUFFMAN_ONLY.\n  zdict\n    The predefined compression dictionary - a sequence of bytes\n    containing subsequences that are likely to occur in the input data.")),
    ("zlib.crc32", Some("Compute a CRC-32 checksum of data.\n\n  value\n    Starting value of the checksum.\n\nThe returned checksum is an integer.")),
    ("zlib.decompress", Some("Returns a bytes object containing the uncompressed data.\n\n  data\n    Compressed data.\n  wbits\n    The window buffer size and container format.\n  bufsize\n    The initial output buffer size.")),
    ("zlib.decompressobj", Some("Return a decompressor object.\n\n  wbits\n    The window buffer size and container format.\n  zdict\n    The predefined compression dictionary.  This must be the same\n    dictionary as used by the compressor that produced the input data.")),
    ("zlib.error.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("zlib.error.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("zlib.error.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.bytearray_iterator", None),
    ("builtins.bytearray_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.bytearray_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.bytearray_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.bytes_iterator", None),
    ("builtins.bytes_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.bytes_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.bytes_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.dict_keyiterator", None),
    ("builtins.dict_keyiterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.dict_keyiterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.dict_keyiterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.dict_valueiterator", None),
    ("builtins.dict_valueiterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.dict_valueiterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.dict_valueiterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.dict_itemiterator", None),
    ("builtins.dict_itemiterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.dict_itemiterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.dict_itemiterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.dict_values", None),
    ("builtins.dict_values.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.dict_values.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.dict_values.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.dict_items", None),
    ("builtins.dict_items.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.dict_items.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.dict_items.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.set_iterator", None),
    ("builtins.set_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.set_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.set_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.list_iterator", None),
    ("builtins.list_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.list_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.list_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.range_iterator", None),
    ("builtins.range_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.range_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.range_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.str_ascii_iterator", None),
    ("builtins.str_ascii_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.str_ascii_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.str_ascii_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.tuple_iterator", None),
    ("builtins.tuple_iterator.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.tuple_iterator.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.tuple_iterator.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.NoneType", None),
    ("builtins.NoneType.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.NoneType.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.NoneType.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
    ("builtins.function", Some("Create a function object.\n\n  code\n    a code object\n  globals\n    the globals dictionary\n  name\n    a string that overrides the name from the code object\n  argdefs\n    a tuple that specifies the default argument values\n  closure\n    a tuple that supplies the bindings for free variables")),
    ("builtins.function.__init_subclass__", Some("This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n")),
    ("builtins.function.__new__", Some("Create and return a new object.  See help(type) for accurate signature.")),
    ("builtins.function.__subclasshook__", Some("Abstract classes can override this to customize issubclass().\n\nThis is invoked early on by abc.ABCMeta.__subclasscheck__().\nIt should return True, False or NotImplemented.  If it returns\nNotImplemented, the normal algorithm is used.  Otherwise, it\noverrides the normal algorithm (and the outcome is cached).\n")),
]