docs.json

{
    "_abc": "Module contains faster C implementation of abc.ABCMeta",
    "_abc._abc_init": "Internal ABC helper for class set-up. Should be never used outside abc module.",
    "_abc._abc_instancecheck": "Internal ABC helper for instance checks. Should be never used outside abc module.",
    "_abc._abc_register": "Internal ABC helper for subclasss registration. Should be never used outside abc module.",
    "_abc._abc_subclasscheck": "Internal ABC helper for subclasss checks. Should be never used outside abc module.",
    "_abc._get_dump": "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": "Internal ABC helper to reset both caches of a given class.\n\nShould be only used by refleak.py",
    "_abc._reset_registry": "Internal ABC helper to reset registry of a given class.\n\nShould be only used by refleak.py",
    "_abc.get_cache_token": "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.",
    "_asyncio": "Accelerator module for asyncio",
    "_asyncio.Future": "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__": null,
    "_asyncio.Future.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_asyncio.Future.__subclasshook__": "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": "A coroutine wrapped in a Future.",
    "_asyncio.Task.__class_getitem__": null,
    "_asyncio.Task.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_asyncio.Task.__subclasshook__": "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": "Enter into task execution or resume suspended task.\n\nTask belongs to loop.\n\nReturns None.",
    "_asyncio._get_running_loop": "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": "Leave task execution or suspend a task.\n\nTask belongs to loop.\n\nReturns None.",
    "_asyncio._register_task": "Register a new task in asyncio as executed by loop.\n\nReturns None.",
    "_asyncio._set_running_loop": "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": "Unregister a task.\n\nReturns None.",
    "_asyncio.get_event_loop": "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": "Return the running event loop.  Raise a RuntimeError if there is none.\n\nThis function is thread-specific.",
    "_bisect": "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": "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, i points just\nbefore 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": "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, i points just\nbeyond 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": "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": "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": "_blake2b provides BLAKE2b for hashlib\n",
    "_blake2.blake2b": "Return a new BLAKE2b hash object.",
    "_blake2.blake2b.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_blake2.blake2b.__subclasshook__": "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": "Return a new BLAKE2s hash object.",
    "_blake2.blake2s.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_blake2.blake2s.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_bz2.BZ2Compressor.__subclasshook__": "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": "Create a decompressor object for decompressing data incrementally.\n\nFor one-shot decompression, use the decompress() function instead.",
    "_bz2.BZ2Decompressor.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_bz2.BZ2Decompressor.__subclasshook__": "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._forget_codec": "Purge the named codec from the internal codec lookup cache",
    "_codecs.ascii_decode": null,
    "_codecs.ascii_encode": null,
    "_codecs.charmap_build": null,
    "_codecs.charmap_decode": null,
    "_codecs.charmap_encode": null,
    "_codecs.decode": "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": "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": null,
    "_codecs.escape_encode": null,
    "_codecs.latin_1_decode": null,
    "_codecs.latin_1_encode": null,
    "_codecs.lookup": "Looks up a codec tuple in the Python codec registry and returns a CodecInfo object.",
    "_codecs.lookup_error": "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": null,
    "_codecs.raw_unicode_escape_encode": null,
    "_codecs.readbuffer_encode": null,
    "_codecs.register": "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": "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": null,
    "_codecs.unicode_escape_encode": null,
    "_codecs.utf_16_be_decode": null,
    "_codecs.utf_16_be_encode": null,
    "_codecs.utf_16_decode": null,
    "_codecs.utf_16_encode": null,
    "_codecs.utf_16_ex_decode": null,
    "_codecs.utf_16_le_decode": null,
    "_codecs.utf_16_le_encode": null,
    "_codecs.utf_32_be_decode": null,
    "_codecs.utf_32_be_encode": null,
    "_codecs.utf_32_decode": null,
    "_codecs.utf_32_encode": null,
    "_codecs.utf_32_ex_decode": null,
    "_codecs.utf_32_le_decode": null,
    "_codecs.utf_32_le_encode": null,
    "_codecs.utf_7_decode": null,
    "_codecs.utf_7_encode": null,
    "_codecs.utf_8_decode": null,
    "_codecs.utf_8_encode": null,
    "_codecs_cn.getcodec": null,
    "_codecs_hk.getcodec": null,
    "_codecs_iso2022.getcodec": null,
    "_codecs_jp.getcodec": null,
    "_codecs_kr.getcodec": null,
    "_codecs_tw.getcodec": null,
    "_collections": "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": "Count elements in the iterable, updating the mapping",
    "_collections._deque_iterator.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_collections._deque_iterator.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_collections._deque_reverse_iterator.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_collections._tuplegetter.__subclasshook__": "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": "Context Variables",
    "_contextvars.copy_context": null,
    "_crypt.crypt": "Hash a *word* with the given *salt* and return the hashed password.\n\n*word* will usually be a user's password.  *salt* (either a random 2 or 16\ncharacter string, possibly prefixed with $digit$ to indicate the method)\nwill be used to perturb the encryption algorithm and produce distinct\nresults for a given *word*.",
    "_csv": "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 whitespace which\n        immediately follows a delimiter.  It defaults to False, which\n        means that whitespace 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": "CSV dialect\n\nThe Dialect type records CSV parsing and generation options.\n",
    "_csv.Dialect.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_csv.Dialect.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_csv.Error.__subclasshook__": "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": "Sets an upper limit on parsed fields.\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": "Return the dialect instance associated with name.\n    dialect = csv.get_dialect(name)",
    "_csv.list_dialects": "Return a list of all know dialect names.\n    names = csv.list_dialects()",
    "_csv.reader": "    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": "Create a mapping from a string name to a dialect class.\n    dialect = csv.register_dialect(name[, dialect[, **fmtparams]])",
    "_csv.unregister_dialect": "Delete the name/dialect mapping associated with a string name.\n    csv.unregister_dialect(name)",
    "_csv.writer": "    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": "Create and manipulate C compatible data types in Python.",
    "_ctypes.POINTER": null,
    "_ctypes.PyObj_FromPtr": null,
    "_ctypes.Py_DECREF": null,
    "_ctypes.Py_INCREF": null,
    "_ctypes._unpickle": null,
    "_ctypes.addressof": "addressof(C instance) -> integer\nReturn the address of the C instance internal buffer",
    "_ctypes.alignment": "alignment(C type) -> integer\nalignment(C instance) -> integer\nReturn the alignment requirements of a C instance",
    "_ctypes.buffer_info": "Return buffer interface information",
    "_ctypes.byref": "byref(C instance[, offset=0]) -> byref-object\nReturn a pointer lookalike to a C instance, only usable\nas function argument",
    "_ctypes.call_cdeclfunction": null,
    "_ctypes.call_function": null,
    "_ctypes.dlclose": "dlclose a library",
    "_ctypes.dlopen": "dlopen(name, flag={RTLD_GLOBAL|RTLD_LOCAL}) open a shared library",
    "_ctypes.dlsym": "find symbol in shared library",
    "_ctypes.get_errno": null,
    "_ctypes.pointer": null,
    "_ctypes.resize": "Resize the memory buffer of a ctypes instance",
    "_ctypes.set_errno": null,
    "_ctypes.sizeof": "sizeof(C type) -> integer\nsizeof(C instance) -> integer\nReturn the size in bytes of a C instance",
    "_ctypes_test.func": null,
    "_ctypes_test.func_si": null,
    "_curses.baudrate": "Return the output speed of the terminal in bits per second.",
    "_curses.beep": "Emit a short attention sound.",
    "_curses.can_change_color": "Return True if the programmer can change the colors displayed by the terminal.",
    "_curses.cbreak": "Enter cbreak mode.\n\n  flag\n    If false, the effect is the same as calling nocbreak().\n\nIn cbreak mode (sometimes called \"rare\" mode) normal tty line buffering is\nturned off and characters are available to be read one by one.  However,\nunlike raw mode, special characters (interrupt, quit, suspend, and flow\ncontrol) retain their effects on the tty driver and calling program.\nCalling first raw() then cbreak() leaves the terminal in cbreak mode.",
    "_curses.color_content": "Return the red, green, and blue (RGB) components of the specified color.\n\n  color_number\n    The number of the color (0 - (COLORS-1)).\n\nA 3-tuple is returned, containing the R, G, B values for the given color,\nwhich will be between 0 (no component) and 1000 (maximum amount of component).",
    "_curses.color_pair": "Return the attribute value for displaying text in the specified color.\n\n  pair_number\n    The number of the color pair.\n\nThis attribute value can be combined with A_STANDOUT, A_REVERSE, and the\nother A_* attributes.  pair_number() is the counterpart to this function.",
    "_curses.curs_set": "Set the cursor state.\n\n  visibility\n    0 for invisible, 1 for normal visible, or 2 for very visible.\n\nIf the terminal supports the visibility requested, the previous cursor\nstate is returned; otherwise, an exception is raised.  On many terminals,\nthe \"visible\" mode is an underline cursor and the \"very visible\" mode is\na block cursor.",
    "_curses.def_prog_mode": "Save the current terminal mode as the \"program\" mode.\n\nThe \"program\" mode is the mode when the running program is using curses.\n\nSubsequent calls to reset_prog_mode() will restore this mode.",
    "_curses.def_shell_mode": "Save the current terminal mode as the \"shell\" mode.\n\nThe \"shell\" mode is the mode when the running program is not using curses.\n\nSubsequent calls to reset_shell_mode() will restore this mode.",
    "_curses.delay_output": "Insert a pause in output.\n\n  ms\n    Duration in milliseconds.",
    "_curses.doupdate": "Update the physical screen to match the virtual screen.",
    "_curses.echo": "Enter echo mode.\n\n  flag\n    If false, the effect is the same as calling noecho().\n\nIn echo mode, each character input is echoed to the screen as it is entered.",
    "_curses.endwin": "De-initialize the library, and return terminal to normal status.",
    "_curses.erasechar": "Return the user's current erase character.",
    "_curses.error.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_curses.error.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_curses.error.__subclasshook__": "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",
    "_curses.filter": null,
    "_curses.flash": "Flash the screen.\n\nThat is, change it to reverse-video and then change it back in a short interval.",
    "_curses.flushinp": "Flush all input buffers.\n\nThis throws away any typeahead that has been typed by the user and has not\nyet been processed by the program.",
    "_curses.get_escdelay": "Gets the curses ESCDELAY setting.\n\nGets the number of milliseconds to wait after reading an escape character,\nto distinguish between an individual escape character entered on the\nkeyboard from escape sequences sent by cursor and function keys.",
    "_curses.get_tabsize": "Gets the curses TABSIZE setting.\n\nGets the number of columns used by the curses library when converting a tab\ncharacter to spaces as it adds the tab to a window.",
    "_curses.getmouse": "Retrieve the queued mouse event.\n\nAfter getch() returns KEY_MOUSE to signal a mouse event, this function\nreturns a 5-tuple (id, x, y, z, bstate).",
    "_curses.getsyx": "Return the current coordinates of the virtual screen cursor.\n\nReturn a (y, x) tuple.  If leaveok is currently true, return (-1, -1).",
    "_curses.getwin": "Read window related data stored in the file by an earlier putwin() call.\n\nThe routine then creates and initializes a new window using that data,\nreturning the new window object.",
    "_curses.halfdelay": "Enter half-delay mode.\n\n  tenths\n    Maximal blocking delay in tenths of seconds (1 - 255).\n\nUse nocbreak() to leave half-delay mode.",
    "_curses.has_colors": "Return True if the terminal can display colors; otherwise, return False.",
    "_curses.has_ic": "Return True if the terminal has insert- and delete-character capabilities.",
    "_curses.has_il": "Return True if the terminal has insert- and delete-line capabilities.",
    "_curses.has_key": "Return True if the current terminal type recognizes a key with that value.\n\n  key\n    Key number.",
    "_curses.init_color": "Change the definition of a color.\n\n  color_number\n    The number of the color to be changed (0 - (COLORS-1)).\n  r\n    Red component (0 - 1000).\n  g\n    Green component (0 - 1000).\n  b\n    Blue component (0 - 1000).\n\nWhen init_color() is used, all occurrences of that color on the screen\nimmediately change to the new definition.  This function is a no-op on\nmost terminals; it is active only if can_change_color() returns true.",
    "_curses.init_pair": "Change the definition of a color-pair.\n\n  pair_number\n    The number of the color-pair to be changed (1 - (COLOR_PAIRS-1)).\n  fg\n    Foreground color number (-1 - (COLORS-1)).\n  bg\n    Background color number (-1 - (COLORS-1)).\n\nIf the color-pair was previously initialized, the screen is refreshed and\nall occurrences of that color-pair are changed to the new definition.",
    "_curses.initscr": "Initialize the library.\n\nReturn a WindowObject which represents the whole screen.",
    "_curses.intrflush": null,
    "_curses.is_term_resized": "Return True if resize_term() would modify the window structure, False otherwise.\n\n  nlines\n    Height.\n  ncols\n    Width.",
    "_curses.isendwin": "Return True if endwin() has been called.",
    "_curses.keyname": "Return the name of specified key.\n\n  key\n    Key number.",
    "_curses.killchar": "Return the user's current line kill character.",
    "_curses.longname": "Return the terminfo long name field describing the current terminal.\n\nThe maximum length of a verbose description is 128 characters.  It is defined\nonly after the call to initscr().",
    "_curses.meta": "Enable/disable meta keys.\n\nIf yes is True, allow 8-bit characters to be input.  If yes is False,\nallow only 7-bit characters.",
    "_curses.mouseinterval": "Set and retrieve the maximum time between press and release in a click.\n\n  interval\n    Time in milliseconds.\n\nSet the maximum time that can elapse between press and release events in\norder for them to be recognized as a click, and return the previous interval\nvalue.",
    "_curses.mousemask": "Set the mouse events to be reported, and return a tuple (availmask, oldmask).\n\nReturn a tuple (availmask, oldmask).  availmask indicates which of the\nspecified mouse events can be reported; on complete failure it returns 0.\noldmask is the previous value of the given window's mouse event mask.\nIf this function is never called, no mouse events are ever reported.",
    "_curses.napms": "Sleep for specified time.\n\n  ms\n    Duration in milliseconds.",
    "_curses.newpad": "Create and return a pointer to a new pad data structure.\n\n  nlines\n    Height.\n  ncols\n    Width.",
    "_curses.newwin": "newwin(nlines, ncols, [begin_y=0, begin_x=0])\nReturn a new window.\n\n  nlines\n    Height.\n  ncols\n    Width.\n  begin_y\n    Top side y-coordinate.\n  begin_x\n    Left side x-coordinate.\n\nBy default, the window will extend from the specified position to the lower\nright corner of the screen.",
    "_curses.nl": "Enter newline mode.\n\n  flag\n    If false, the effect is the same as calling nonl().\n\nThis mode translates the return key into newline on input, and translates\nnewline into return and line-feed on output.  Newline mode is initially on.",
    "_curses.nocbreak": "Leave cbreak mode.\n\nReturn to normal \"cooked\" mode with line buffering.",
    "_curses.noecho": "Leave echo mode.\n\nEchoing of input characters is turned off.",
    "_curses.nonl": "Leave newline mode.\n\nDisable translation of return into newline on input, and disable low-level\ntranslation of newline into newline/return on output.",
    "_curses.noqiflush": "Disable queue flushing.\n\nWhen queue flushing is disabled, normal flush of input and output queues\nassociated with the INTR, QUIT and SUSP characters will not be done.",
    "_curses.noraw": "Leave raw mode.\n\nReturn to normal \"cooked\" mode with line buffering.",
    "_curses.pair_content": "Return a tuple (fg, bg) containing the colors for the requested color pair.\n\n  pair_number\n    The number of the color pair (1 - (COLOR_PAIRS-1)).",
    "_curses.pair_number": "Return the number of the color-pair set by the specified attribute value.\n\ncolor_pair() is the counterpart to this function.",
    "_curses.putp": "Emit the value of a specified terminfo capability for the current terminal.\n\nNote that the output of putp() always goes to standard output.",
    "_curses.qiflush": "Enable queue flushing.\n\n  flag\n    If false, the effect is the same as calling noqiflush().\n\nIf queue flushing is enabled, all output in the display driver queue\nwill be flushed when the INTR, QUIT and SUSP characters are read.",
    "_curses.raw": "Enter raw mode.\n\n  flag\n    If false, the effect is the same as calling noraw().\n\nIn raw mode, normal line buffering and processing of interrupt, quit,\nsuspend, and flow control keys are turned off; characters are presented to\ncurses input functions one by one.",
    "_curses.reset_prog_mode": "Restore the terminal to \"program\" mode, as previously saved by def_prog_mode().",
    "_curses.reset_shell_mode": "Restore the terminal to \"shell\" mode, as previously saved by def_shell_mode().",
    "_curses.resetty": "Restore terminal mode.",
    "_curses.resize_term": "Backend function used by resizeterm(), performing most of the work.\n\n  nlines\n    Height.\n  ncols\n    Width.\n\nWhen resizing the windows, resize_term() blank-fills the areas that are\nextended.  The calling application should fill in these areas with appropriate\ndata.  The resize_term() function attempts to resize all windows.  However,\ndue to the calling convention of pads, it is not possible to resize these\nwithout additional interaction with the application.",
    "_curses.resizeterm": "Resize the standard and current windows to the specified dimensions.\n\n  nlines\n    Height.\n  ncols\n    Width.\n\nAdjusts other bookkeeping data used by the curses library that record the\nwindow dimensions (in particular the SIGWINCH handler).",
    "_curses.savetty": "Save terminal mode.",
    "_curses.set_escdelay": "Sets the curses ESCDELAY setting.\n\n  ms\n    length of the delay in milliseconds.\n\nSets the number of milliseconds to wait after reading an escape character,\nto distinguish between an individual escape character entered on the\nkeyboard from escape sequences sent by cursor and function keys.",
    "_curses.set_tabsize": "Sets the curses TABSIZE setting.\n\n  size\n    rendered cell width of a tab character.\n\nSets the number of columns used by the curses library when converting a tab\ncharacter to spaces as it adds the tab to a window.",
    "_curses.setsyx": "Set the virtual screen cursor.\n\n  y\n    Y-coordinate.\n  x\n    X-coordinate.\n\nIf y and x are both -1, then leaveok is set.",
    "_curses.setupterm": "Initialize the terminal.\n\n  term\n    Terminal name.\n    If omitted, the value of the TERM environment variable will be used.\n  fd\n    File descriptor to which any initialization sequences will be sent.\n    If not supplied, the file descriptor for sys.stdout will be used.",
    "_curses.start_color": "Initializes eight basic colors and global variables COLORS and COLOR_PAIRS.\n\nMust be called if the programmer wants to use colors, and before any other\ncolor manipulation routine is called.  It is good practice to call this\nroutine right after initscr().\n\nIt also restores the colors on the terminal to the values they had when the\nterminal was just turned on.",
    "_curses.termattrs": "Return a logical OR of all video attributes supported by the terminal.",
    "_curses.termname": "Return the value of the environment variable TERM, truncated to 14 characters.",
    "_curses.tigetflag": "Return the value of the Boolean capability.\n\n  capname\n    The terminfo capability name.\n\nThe value -1 is returned if capname is not a Boolean capability, or 0 if\nit is canceled or absent from the terminal description.",
    "_curses.tigetnum": "Return the value of the numeric capability.\n\n  capname\n    The terminfo capability name.\n\nThe value -2 is returned if capname is not a numeric capability, or -1 if\nit is canceled or absent from the terminal description.",
    "_curses.tigetstr": "Return the value of the string capability.\n\n  capname\n    The terminfo capability name.\n\nNone is returned if capname is not a string capability, or is canceled or\nabsent from the terminal description.",
    "_curses.tparm": "Instantiate the specified byte string with the supplied parameters.\n\n  str\n    Parameterized byte string obtained from the terminfo database.",
    "_curses.typeahead": "Specify that the file descriptor fd be used for typeahead checking.\n\n  fd\n    File descriptor.\n\nIf fd is -1, then no typeahead checking is done.",
    "_curses.unctrl": "Return a string which is a printable representation of the character ch.\n\nControl characters are displayed as a caret followed by the character,\nfor example as ^C.  Printing characters are left as they are.",
    "_curses.ungetch": "Push ch so the next getch() will return it.",
    "_curses.ungetmouse": "Push a KEY_MOUSE event onto the input queue.\n\nThe following getmouse() will return the given state data.",
    "_curses.update_lines_cols": null,
    "_curses.use_default_colors": "Allow use of default values for colors on terminals supporting this feature.\n\nUse this to support transparency in your application.  The default color\nis assigned to the color number -1.",
    "_curses.use_env": "Use environment variables LINES and COLUMNS.\n\nIf used, this function should be called before initscr() or newterm() are\ncalled.\n\nWhen flag is False, the values of lines and columns specified in the terminfo\ndatabase will be used, even if environment variables LINES and COLUMNS (used\nby default) are set, or if curses is running in a window (in which case\ndefault behavior would be to use the window size if LINES and COLUMNS are\nnot set).",
    "_curses.window.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_curses.window.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_curses.window.__subclasshook__": "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",
    "_curses_panel.bottom_panel": "Return the bottom panel in the panel stack.",
    "_curses_panel.error.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_curses_panel.error.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_curses_panel.error.__subclasshook__": "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",
    "_curses_panel.new_panel": "Return a panel object, associating it with the given window win.",
    "_curses_panel.panel.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_curses_panel.panel.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_curses_panel.panel.__subclasshook__": "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",
    "_curses_panel.top_panel": "Return the top panel in the panel stack.",
    "_curses_panel.update_panels": "Updates the virtual screen after changes in the panel stack.\n\nThis does not call curses.doupdate(), so you'll have to do this yourself.",
    "_datetime": "Fast implementation of the datetime type.",
    "_decimal": "C decimal arithmetic module",
    "_elementtree.SubElement": null,
    "_elementtree._set_factories": "Change the factories used to create comments and processing instructions.\n\nFor internal use only.",
    "_functools": "Tools that operate on functions.",
    "_functools.cmp_to_key": "Convert a cmp= function into a key= function.",
    "_functools.reduce": "reduce(function, sequence[, initial]) -> value\n\nApply a function of two arguments cumulatively to the items of a sequence,\nfrom left to right, so as to reduce the sequence to a single value.\nFor 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 sequence in the calculation, and serves as a default when the\nsequence is empty.",
    "_hashlib": "OpenSSL interface for hashlib module",
    "_hashlib.HASH": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_hashlib.HASH.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_hashlib.HASHXOF.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_hashlib.HMAC.__subclasshook__": "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": "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": "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": "Single-shot HMAC.",
    "_hashlib.hmac_new": "Return a new hmac object.",
    "_hashlib.new": "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": "Returns a md5 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha1": "Returns a sha1 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha224": "Returns a sha224 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha256": "Returns a sha256 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha384": "Returns a sha384 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha3_224": "Returns a sha3-224 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha3_256": "Returns a sha3-256 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha3_384": "Returns a sha3-384 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha3_512": "Returns a sha3-512 hash object; optionally initialized with a string",
    "_hashlib.openssl_sha512": "Returns a sha512 hash object; optionally initialized with a string",
    "_hashlib.openssl_shake_128": "Returns a shake-128 variable hash object; optionally initialized with a string",
    "_hashlib.openssl_shake_256": "Returns a shake-256 variable hash object; optionally initialized with a string",
    "_hashlib.pbkdf2_hmac": "Password based key derivation function 2 (PKCS #5 v2.0) with HMAC as pseudorandom function.",
    "_hashlib.scrypt": "scrypt password-based key derivation function.",
    "_heapq": "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": "Maxheap variant of heapify.",
    "_heapq._heappop_max": "Maxheap variant of heappop.",
    "_heapq._heapreplace_max": "Maxheap variant of heapreplace.",
    "_heapq.heapify": "Transform list into a heap, in-place, in O(len(heap)) time.",
    "_heapq.heappop": "Pop the smallest item off the heap, maintaining the heap invariant.",
    "_heapq.heappush": "Push item onto heap, maintaining the heap invariant.",
    "_heapq.heappushpop": "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": "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)",
    "_imp": "(Extremely) low-level import machinery bits as used by importlib and imp.",
    "_imp._fix_co_filename": "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.acquire_lock": "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": "Create an extension module.",
    "_imp.create_dynamic": "Create an extension module.",
    "_imp.exec_builtin": "Initialize a built-in module.",
    "_imp.exec_dynamic": "Initialize an extension module.",
    "_imp.extension_suffixes": "Returns the list of file suffixes used to identify extension modules.",
    "_imp.get_frozen_object": "Create a code object for a frozen module.",
    "_imp.init_frozen": "Initializes a frozen module.",
    "_imp.is_builtin": "Returns True if the module name corresponds to a built-in module.",
    "_imp.is_frozen": "Returns True if the module name corresponds to a frozen module.",
    "_imp.is_frozen_package": "Returns True if the module name is of a frozen package.",
    "_imp.lock_held": "Return True if the import lock is currently held, else False.\n\nOn platforms without threads, return False.",
    "_imp.release_lock": "Release the interpreter's import lock.\n\nOn platforms without threads, this function does nothing.",
    "_imp.source_hash": null,
    "_io": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.BufferedRWPair.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.BufferedRandom.__subclasshook__": "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": "Create a new buffered reader using the given readable raw IO object.",
    "_io.BufferedReader.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.BufferedReader.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.BufferedWriter.__subclasshook__": "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": "Buffered I/O implementation using an in-memory bytes buffer.",
    "_io.BytesIO.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.BytesIO.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.FileIO.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.IncrementalNewlineDecoder.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.StringIO.__subclasshook__": "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": "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.getpreferredencoding(False).\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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io.TextIOWrapper.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io._BufferedIOBase.__subclasshook__": "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": "The abstract base class for all I/O classes, acting on streams of\nbytes. There is no public constructor.\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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io._IOBase.__subclasshook__": "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": "Base class for raw binary I/O.",
    "_io._RawIOBase.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io._RawIOBase.__subclasshook__": "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": "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. There is no public constructor.\n",
    "_io._TextIOBase.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_io._TextIOBase.__subclasshook__": "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": "json speedups\n",
    "_json.encode_basestring": "encode_basestring(string) -> string\n\nReturn a JSON representation of a Python string",
    "_json.encode_basestring_ascii": "encode_basestring_ascii(string) -> string\n\nReturn an ASCII-only JSON representation of a Python string",
    "_json.make_encoder": "_iterencode(obj, _current_indent_level) -> iterable",
    "_json.make_encoder.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_json.make_encoder.__subclasshook__": "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": "JSON scanner object",
    "_json.make_scanner.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_json.make_scanner.__subclasshook__": "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": "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.",
    "_locale": "Support for POSIX locales.",
    "_locale.bind_textdomain_codeset": "bind_textdomain_codeset(domain, codeset) -> string\nBind the C library's domain to codeset.",
    "_locale.bindtextdomain": "bindtextdomain(domain, dir) -> string\nBind the C library's domain to dir.",
    "_locale.dcgettext": "dcgettext(domain, msg, category) -> string\nReturn translation of msg in domain and category.",
    "_locale.dgettext": "dgettext(domain, msg) -> string\nReturn translation of msg in domain.",
    "_locale.gettext": "gettext(msg) -> string\nReturn translation of msg.",
    "_locale.localeconv": "() -> dict. Returns numeric and monetary locale-specific parameters.",
    "_locale.nl_langinfo": "nl_langinfo(key) -> string\nReturn the value for the locale information associated with key.",
    "_locale.setlocale": "(integer,string=None) -> string. Activates/queries locale processing.",
    "_locale.strcoll": "string,string -> int. Compares two strings according to the locale.",
    "_locale.strxfrm": "strxfrm(string) -> string.\n\nReturn a string that can be used as a key for locale-aware comparisons.",
    "_locale.textdomain": "textdomain(domain) -> string\nSet the C library's textdmain to domain, returning the new domain.",
    "_lsprof": "Fast profiler",
    "_lsprof.Profiler": "Profiler(timer=None, timeunit=None, subcalls=True, builtins=True)\n\n    Builds a profiler object using the specified timer function.\n    The default timer is a fast built-in one based on real time.\n    For custom timer functions returning integers, timeunit can\n    be a float specifying a scale (i.e. how long each integer unit\n    is, in seconds).\n",
    "_lsprof.Profiler.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_lsprof.Profiler.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_lsprof.Profiler.__subclasshook__": "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",
    "_lsprof.profiler_entry.__class_getitem__": "See PEP 585",
    "_lsprof.profiler_entry.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_lsprof.profiler_entry.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_lsprof.profiler_entry.__subclasshook__": "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",
    "_lsprof.profiler_subentry.__class_getitem__": "See PEP 585",
    "_lsprof.profiler_subentry.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_lsprof.profiler_subentry.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_lsprof.profiler_subentry.__subclasshook__": "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",
    "_lzma.LZMACompressor": "LZMACompressor(format=FORMAT_XZ, check=-1, preset=None, filters=None)\n\nCreate a compressor object for compressing data incrementally.\n\nformat specifies the container format to use for the output. This can\nbe FORMAT_XZ (default), FORMAT_ALONE, or FORMAT_RAW.\n\ncheck specifies the integrity check to use. For FORMAT_XZ, the default\nis CHECK_CRC64. FORMAT_ALONE and FORMAT_RAW do not support integrity\nchecks; for these formats, check must be omitted, or be CHECK_NONE.\n\nThe settings used by the compressor can be specified either as a\npreset compression level (with the 'preset' argument), or in detail\nas a custom filter chain (with the 'filters' argument). For FORMAT_XZ\nand FORMAT_ALONE, the default is to use the PRESET_DEFAULT preset\nlevel. For FORMAT_RAW, the caller must always specify a filter chain;\nthe raw compressor does not support preset compression levels.\n\npreset (if provided) should be an integer in the range 0-9, optionally\nOR-ed with the constant PRESET_EXTREME.\n\nfilters (if provided) should be a sequence of dicts. Each dict should\nhave an entry for \"id\" indicating the ID of the filter, plus\nadditional entries for options to the filter.\n\nFor one-shot compression, use the compress() function instead.\n",
    "_lzma.LZMACompressor.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_lzma.LZMACompressor.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_lzma.LZMACompressor.__subclasshook__": "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",
    "_lzma.LZMADecompressor": "Create a decompressor object for decompressing data incrementally.\n\n  format\n    Specifies the container format of the input stream.  If this is\n    FORMAT_AUTO (the default), the decompressor will automatically detect\n    whether the input is FORMAT_XZ or FORMAT_ALONE.  Streams created with\n    FORMAT_RAW cannot be autodetected.\n  memlimit\n    Limit the amount of memory used by the decompressor.  This will cause\n    decompression to fail if the input cannot be decompressed within the\n    given limit.\n  filters\n    A custom filter chain.  This argument is required for FORMAT_RAW, and\n    not accepted with any other format.  When provided, this should be a\n    sequence of dicts, each indicating the ID and options for a single\n    filter.\n\nFor one-shot decompression, use the decompress() function instead.",
    "_lzma.LZMADecompressor.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_lzma.LZMADecompressor.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_lzma.LZMADecompressor.__subclasshook__": "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",
    "_lzma.LZMAError": "Call to liblzma failed.",
    "_lzma.LZMAError.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_lzma.LZMAError.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_lzma.LZMAError.__subclasshook__": "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",
    "_lzma._decode_filter_properties": "Return a bytes object encoding the options (properties) of the filter specified by *filter* (a dict).\n\nThe result does not include the filter ID itself, only the options.",
    "_lzma._encode_filter_properties": "Return a bytes object encoding the options (properties) of the filter specified by *filter* (a dict).\n\nThe result does not include the filter ID itself, only the options.",
    "_lzma.is_check_supported": "Test whether the given integrity check is supported.\n\nAlways returns True for CHECK_NONE and CHECK_CRC32.",
    "_md5.MD5Type.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_md5.MD5Type.__subclasshook__": "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": "Return a new MD5 hash object; optionally initialized with a string.",
    "_multibytecodec.__create_codec": null,
    "_multiprocessing.SemLock": "Semaphore/Mutex type",
    "_multiprocessing.SemLock.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_multiprocessing.SemLock.__subclasshook__": "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": null,
    "_multiprocessing.sem_unlink": null,
    "_opcode": "Opcode support module.",
    "_opcode.stack_effect": "Compute the stack effect of the opcode.",
    "_operator": "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": "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": "Same as abs(a).",
    "_operator.add": "Same as a + b.",
    "_operator.and_": "Same as a & b.",
    "_operator.concat": "Same as a + b, for a and b sequences.",
    "_operator.contains": "Same as b in a (note reversed operands).",
    "_operator.countOf": "Return the number of times b occurs in a.",
    "_operator.delitem": "Same as del a[b].",
    "_operator.eq": "Same as a == b.",
    "_operator.floordiv": "Same as a // b.",
    "_operator.ge": "Same as a >= b.",
    "_operator.getitem": "Same as a[b].",
    "_operator.gt": "Same as a > b.",
    "_operator.iadd": "Same as a += b.",
    "_operator.iand": "Same as a &= b.",
    "_operator.iconcat": "Same as a += b, for a and b sequences.",
    "_operator.ifloordiv": "Same as a //= b.",
    "_operator.ilshift": "Same as a <<= b.",
    "_operator.imatmul": "Same as a @= b.",
    "_operator.imod": "Same as a %= b.",
    "_operator.imul": "Same as a *= b.",
    "_operator.index": "Same as a.__index__()",
    "_operator.indexOf": "Return the first index of b in a.",
    "_operator.inv": "Same as ~a.",
    "_operator.invert": "Same as ~a.",
    "_operator.ior": "Same as a |= b.",
    "_operator.ipow": "Same as a **= b.",
    "_operator.irshift": "Same as a >>= b.",
    "_operator.is_": "Same as a is b.",
    "_operator.is_not": "Same as a is not b.",
    "_operator.isub": "Same as a -= b.",
    "_operator.itruediv": "Same as a /= b.",
    "_operator.ixor": "Same as a ^= b.",
    "_operator.le": "Same as a <= b.",
    "_operator.length_hint": "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": "Same as a << b.",
    "_operator.lt": "Same as a < b.",
    "_operator.matmul": "Same as a @ b.",
    "_operator.mod": "Same as a % b.",
    "_operator.mul": "Same as a * b.",
    "_operator.ne": "Same as a != b.",
    "_operator.neg": "Same as -a.",
    "_operator.not_": "Same as not a.",
    "_operator.or_": "Same as a | b.",
    "_operator.pos": "Same as +a.",
    "_operator.pow": "Same as a ** b.",
    "_operator.rshift": "Same as a >> b.",
    "_operator.setitem": "Same as a[b] = c.",
    "_operator.sub": "Same as a - b.",
    "_operator.truediv": "Same as a / b.",
    "_operator.truth": "Return True if a is true, False otherwise.",
    "_operator.xor": "Same as a ^ b.",
    "_peg_parser": "A parser.",
    "_pickle": "Optimized C implementation for the Python pickle module.",
    "_pickle.PickleError.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_pickle.PickleError.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_pickle.Pickler.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_pickle.PicklingError.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_pickle.Unpickler.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_pickle.UnpicklingError.__subclasshook__": "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": "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": "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": "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": "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.",
    "_posixshmem": "POSIX shared memory module",
    "_posixshmem.shm_open": "Open a shared memory object.  Returns a file descriptor (integer).",
    "_posixshmem.shm_unlink": "Remove a shared memory object (similar to unlink()).\n\nRemove a shared memory object name, and, once all processes  have  unmapped\nthe object, de-allocates and destroys the contents of the associated memory\nregion.",
    "_posixsubprocess": "A POSIX helper for the subprocess module.",
    "_posixsubprocess.fork_exec": "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,\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": "C implementation of the Python queue module.\nThis module is an implementation detail, please do not use it directly.",
    "_queue.Empty": "Exception raised by Queue.get(block=0)/get_nowait().",
    "_queue.Empty.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_queue.Empty.__subclasshook__": "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": "Simple, unbounded, reentrant FIFO queue.",
    "_queue.SimpleQueue.__class_getitem__": "See PEP 585",
    "_queue.SimpleQueue.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_queue.SimpleQueue.__subclasshook__": "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": "Module implements the Mersenne Twister random number generator.",
    "_random.Random": "Random() -> create a random number generator with its own internal state.",
    "_random.Random.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_random.Random.__subclasshook__": "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.SHA1Type.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha1.SHA1Type.__subclasshook__": "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": "Return a new SHA1 hash object; optionally initialized with a string.",
    "_sha256.SHA224Type.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha256.SHA224Type.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha256.SHA256Type.__subclasshook__": "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": "Return a new SHA-224 hash object; optionally initialized with a string.",
    "_sha256.sha256": "Return a new SHA-256 hash object; optionally initialized with a string.",
    "_sha3.sha3_224": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha3.sha3_224.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha3.sha3_256.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha3.sha3_384.__subclasshook__": "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": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha3.sha3_512.__subclasshook__": "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": "shake_128([data], *, usedforsecurity=True) -> SHAKE object\n\nReturn a new SHAKE hash object.",
    "_sha3.shake_128.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha3.shake_128.__subclasshook__": "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": "shake_256([data], *, usedforsecurity=True) -> SHAKE object\n\nReturn a new SHAKE hash object.",
    "_sha3.shake_256.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha3.shake_256.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha512.SHA384Type.__subclasshook__": "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.SHA512Type.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_sha512.SHA512Type.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_sha512.SHA512Type.__subclasshook__": "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": "Return a new SHA-384 hash object; optionally initialized with a string.",
    "_sha512.sha512": "Return a new SHA-512 hash object; optionally initialized with a string.",
    "_signal": "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": "Arrange for SIGALRM to arrive after the given number of seconds.",
    "_signal.default_int_handler": "default_int_handler(...)\n\nThe default handler for SIGINT installed by Python.\nIt raises KeyboardInterrupt.",
    "_signal.getitimer": "Returns current value of given itimer.",
    "_signal.getsignal": "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": "Wait until a signal arrives.",
    "_signal.pthread_kill": "Send a signal to a thread.",
    "_signal.pthread_sigmask": "Fetch and/or change the signal mask of the calling thread.",
    "_signal.raise_signal": "Send a signal to the executing process.",
    "_signal.set_wakeup_fd": "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": "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": "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": "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": "Examine pending signals.\n\nReturns a set of signal numbers that are pending for delivery to\nthe calling thread.",
    "_signal.sigtimedwait": "Like sigwaitinfo(), but with a timeout.\n\nThe timeout is specified in seconds, with floating point numbers allowed.",
    "_signal.sigwait": "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.sigwaitinfo": "Wait synchronously until one of the signals in *sigset* is delivered.\n\nReturns a struct_siginfo containing information about the signal.",
    "_signal.strsignal": "Return the system description of the given signal.\n\nThe return values can be such as \"Interrupt\", \"Segmentation fault\", etc.\nReturns None if the signal is not recognized.",
    "_signal.valid_signals": "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`.",
    "_socket": "Implementation module for socket operations.\n\nSee the socket module for documentation.",
    "_socket.CMSG_LEN": "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": "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": "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\nif_nameindex() -- return all network interface indices and names\nif_nametoindex(name) -- return the corresponding interface index\nif_indextoname(index) -- return the corresponding interface name\n\n [*] not available on all platforms!",
    "_socket.SocketType.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_socket.SocketType.__subclasshook__": "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": "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": "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": "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": "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": "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": "gethostbyname(host) -> address\n\nReturn the IP address (a string of the form '255.255.255.255') for a host.",
    "_socket.gethostbyname_ex": "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": "gethostname() -> string\n\nReturn the current host name.",
    "_socket.getnameinfo": "getnameinfo(sockaddr, flags) --> (host, port)\n\nGet host and port for a sockaddr.",
    "_socket.getprotobyname": "getprotobyname(name) -> integer\n\nReturn the protocol number for the named protocol.  (Rarely used.)",
    "_socket.getservbyname": "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": "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": "htonl(integer) -> integer\n\nConvert a 32-bit integer from host to network byte order.",
    "_socket.htons": "htons(integer) -> integer\n\nConvert a 16-bit unsigned integer from host to network byte order.\nNote that in case the received integer does not fit in 16-bit unsigned\ninteger, but does fit in a positive C int, it is silently truncated to\n16-bit unsigned integer.\nHowever, this silent truncation feature is deprecated, and will raise an\nexception in future versions of Python.",
    "_socket.if_indextoname": "if_indextoname(if_index)\n\nReturns the interface name corresponding to the interface index if_index.",
    "_socket.if_nameindex": "if_nameindex()\n\nReturns a list of network interface information (index, name) tuples.",
    "_socket.if_nametoindex": "if_nametoindex(if_name)\n\nReturns the interface index corresponding to the interface name if_name.",
    "_socket.inet_aton": "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": "inet_ntoa(packed_ip) -> ip_address_string\n\nConvert an IP address from 32-bit packed binary format to string format",
    "_socket.inet_ntop": "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": "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": "ntohl(integer) -> integer\n\nConvert a 32-bit integer from network to host byte order.",
    "_socket.ntohs": "ntohs(integer) -> integer\n\nConvert a 16-bit unsigned integer from network to host byte order.\nNote that in case the received integer does not fit in 16-bit unsigned\ninteger, but does fit in a positive C int, it is silently truncated to\n16-bit unsigned integer.\nHowever, this silent truncation feature is deprecated, and will raise an\nexception in future versions of Python.",
    "_socket.setdefaulttimeout": "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": "sethostname(name)\n\nSets the hostname to name.",
    "_socket.socket": "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\nif_nameindex() -- return all network interface indices and names\nif_nametoindex(name) -- return the corresponding interface index\nif_indextoname(index) -- return the corresponding interface name\n\n [*] not available on all platforms!",
    "_socket.socket.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_socket.socket.__subclasshook__": "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": "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": "adapt(obj, protocol, alternate) -> adapt obj to given protocol. Non-standard.",
    "_sqlite3.complete_statement": "complete_statement(sql)\n\nChecks if a string contains a complete SQL statement. Non-standard.",
    "_sqlite3.connect": "connect(database[, timeout, detect_types, isolation_level,\n        check_same_thread, factory, cached_statements, uri])\n\nOpens a connection to the SQLite database file *database*. You can use\n\":memory:\" to open a database connection to a database that resides in\nRAM instead of on disk.",
    "_sqlite3.enable_callback_tracebacks": "enable_callback_tracebacks(flag)\n\nEnable or disable callback functions throwing errors to stderr.",
    "_sqlite3.enable_shared_cache": "enable_shared_cache(do_enable)\n\nEnable or disable shared cache mode for the calling thread.\nExperimental/Non-standard.",
    "_sqlite3.register_adapter": "register_adapter(type, callable)\n\nRegisters an adapter with pysqlite's adapter registry. Non-standard.",
    "_sqlite3.register_converter": "register_converter(typename, callable)\n\nRegisters a converter with pysqlite. Non-standard.",
    "_sre.ascii_iscased": null,
    "_sre.ascii_tolower": null,
    "_sre.compile": null,
    "_sre.getcodesize": null,
    "_sre.unicode_iscased": null,
    "_sre.unicode_tolower": null,
    "_ssl": "Implementation module for SSL socket operations.  See the socket module\nfor documentation.",
    "_ssl.MemoryBIO.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_ssl.MemoryBIO.__subclasshook__": "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": "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": "Generate n cryptographically strong pseudo-random bytes.",
    "_ssl.RAND_pseudo_bytes": "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": "Returns 1 if the OpenSSL PRNG has been seeded with enough data and 0 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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_ssl.SSLSession.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_ssl._SSLContext.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_ssl._SSLSocket.__subclasshook__": "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": null,
    "_ssl.get_default_verify_paths": "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": "Lookup NID, short name, long name and OID of an ASN1_OBJECT by NID.",
    "_ssl.txt2obj": "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.",
    "_stat": "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": "Return the portion of the file's mode that describes the file type.",
    "_stat.S_IMODE": "Return the portion of the file's mode that can be set by os.chmod().",
    "_stat.S_ISBLK": "S_ISBLK(mode) -> bool\n\nReturn True if mode is from a block special device file.",
    "_stat.S_ISCHR": "S_ISCHR(mode) -> bool\n\nReturn True if mode is from a character special device file.",
    "_stat.S_ISDIR": "S_ISDIR(mode) -> bool\n\nReturn True if mode is from a directory.",
    "_stat.S_ISDOOR": "S_ISDOOR(mode) -> bool\n\nReturn True if mode is from a door.",
    "_stat.S_ISFIFO": "S_ISFIFO(mode) -> bool\n\nReturn True if mode is from a FIFO (named pipe).",
    "_stat.S_ISLNK": "S_ISLNK(mode) -> bool\n\nReturn True if mode is from a symbolic link.",
    "_stat.S_ISPORT": "S_ISPORT(mode) -> bool\n\nReturn True if mode is from an event port.",
    "_stat.S_ISREG": "S_ISREG(mode) -> bool\n\nReturn True if mode is from a regular file.",
    "_stat.S_ISSOCK": "S_ISSOCK(mode) -> bool\n\nReturn True if mode is from a socket.",
    "_stat.S_ISWHT": "S_ISWHT(mode) -> bool\n\nReturn True if mode is from a whiteout.",
    "_stat.filemode": "Convert a file's mode to a string of the form '-rwxrwxrwx'",
    "_statistics": "Accelerators for the statistics module.\n",
    "_statistics._normal_dist_inv_cdf": null,
    "_string": "string helper module",
    "_string.formatter_field_name_split": "split the argument as a field name",
    "_string.formatter_parser": "parse the argument as a format string",
    "_struct": "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": "Struct(fmt) --> compiled struct object\n\n",
    "_struct.Struct.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_struct.Struct.__subclasshook__": "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": "Clear the internal cache.",
    "_struct.calcsize": "Return size in bytes of the struct described by the format string.",
    "_struct.iter_unpack": "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": "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": "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": "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": "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.",
    "_symtable.symtable": "Return symbol and scope dictionaries used internally by compiler.",
    "_testbuffer.cmp_contig": null,
    "_testbuffer.get_contiguous": null,
    "_testbuffer.get_pointer": null,
    "_testbuffer.get_sizeof_void_p": null,
    "_testbuffer.is_contiguous": null,
    "_testbuffer.py_buffer_to_contiguous": null,
    "_testbuffer.slice_indices": null,
    "_testcapi.ContainerNoGC.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.ContainerNoGC.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.ContainerNoGC.__subclasshook__": "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",
    "_testcapi.DecodeLocaleEx": null,
    "_testcapi.EncodeLocaleEx": null,
    "_testcapi.HeapCTypeSetattr": "A heap type without GC, but with overridden __setattr__.\n\nThe 'value' attribute is set to 10 in __init__ and updated via attribute setting.",
    "_testcapi.HeapCTypeSetattr.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeSetattr.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeSetattr.__subclasshook__": "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",
    "_testcapi.HeapCTypeSubclass": "Subclass of HeapCType, without GC.\n\n__init__ sets the 'value' attribute to 10 and 'value2' to 20.",
    "_testcapi.HeapCTypeSubclass.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeSubclass.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeSubclass.__subclasshook__": "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",
    "_testcapi.HeapCTypeSubclassWithFinalizer": "Subclass of HeapCType with a finalizer that reassigns __class__.\n\n__class__ is set to plain HeapCTypeSubclass during finalization.\n__init__ sets the 'value' attribute to 10 and 'value2' to 20.",
    "_testcapi.HeapCTypeSubclassWithFinalizer.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeSubclassWithFinalizer.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeSubclassWithFinalizer.__subclasshook__": "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",
    "_testcapi.HeapCTypeWithBuffer": "Heap type with buffer support.\n\nThe buffer is set to [b'1', b'2', b'3', b'4']",
    "_testcapi.HeapCTypeWithBuffer.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeWithBuffer.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeWithBuffer.__subclasshook__": "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",
    "_testcapi.HeapCTypeWithDict.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeWithDict.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeWithDict.__subclasshook__": "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",
    "_testcapi.HeapCTypeWithNegativeDict.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeWithNegativeDict.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeWithNegativeDict.__subclasshook__": "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",
    "_testcapi.HeapCTypeWithWeakref.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapCTypeWithWeakref.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapCTypeWithWeakref.__subclasshook__": "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",
    "_testcapi.HeapGcCType": "A heap type with GC, and with overridden dealloc.\n\nThe 'value' attribute is set to 10 in __init__.",
    "_testcapi.HeapGcCType.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.HeapGcCType.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.HeapGcCType.__subclasshook__": "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",
    "_testcapi.PyBuffer_SizeFromFormat": null,
    "_testcapi.PyDateTime_DATE_GET": null,
    "_testcapi.PyDateTime_DELTA_GET": null,
    "_testcapi.PyDateTime_GET": null,
    "_testcapi.PyDateTime_TIME_GET": null,
    "_testcapi.PyTime_AsMicroseconds": null,
    "_testcapi.PyTime_AsMilliseconds": null,
    "_testcapi.PyTime_AsSecondsDouble": null,
    "_testcapi.PyTime_AsTimespec": null,
    "_testcapi.PyTime_AsTimeval": null,
    "_testcapi.PyTime_FromSeconds": null,
    "_testcapi.PyTime_FromSecondsObject": null,
    "_testcapi.W_STOPCODE": null,
    "_testcapi._pending_threadfunc": null,
    "_testcapi._test_thread_state": null,
    "_testcapi.argparsing": null,
    "_testcapi.bad_get": null,
    "_testcapi.call_in_temporary_c_thread": "set_error_class(error_class) -> None",
    "_testcapi.check_pyobject_forbidden_bytes_is_freed": null,
    "_testcapi.check_pyobject_freed_is_freed": null,
    "_testcapi.check_pyobject_null_is_freed": null,
    "_testcapi.check_pyobject_uninitialized_is_freed": null,
    "_testcapi.code_newempty": null,
    "_testcapi.codec_incrementaldecoder": null,
    "_testcapi.codec_incrementalencoder": null,
    "_testcapi.crash_no_current_thread": null,
    "_testcapi.create_cfunction": null,
    "_testcapi.datetime_check_date": null,
    "_testcapi.datetime_check_datetime": null,
    "_testcapi.datetime_check_delta": null,
    "_testcapi.datetime_check_time": null,
    "_testcapi.datetime_check_tzinfo": null,
    "_testcapi.dict_get_version": null,
    "_testcapi.dict_getitem_knownhash": null,
    "_testcapi.dict_hassplittable": null,
    "_testcapi.docstring_empty": null,
    "_testcapi.docstring_no_signature": "This docstring has no signature.",
    "_testcapi.docstring_with_invalid_signature": "docstring_with_invalid_signature($module, /, boo)\n\nThis docstring has an invalid signature.",
    "_testcapi.docstring_with_invalid_signature2": "docstring_with_invalid_signature2($module, /, boo)\n\n--\n\nThis docstring also has an invalid signature.",
    "_testcapi.docstring_with_signature": "This docstring has a valid signature.",
    "_testcapi.docstring_with_signature_and_extra_newlines": "\nThis docstring has a valid signature and some extra newlines.",
    "_testcapi.docstring_with_signature_but_no_doc": null,
    "_testcapi.docstring_with_signature_with_defaults": "\n\nThis docstring has a valid signature with parameters,\nand the parameters take defaults of varying types.",
    "_testcapi.error.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_testcapi.error.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_testcapi.error.__subclasshook__": "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",
    "_testcapi.exception_print": null,
    "_testcapi.get_args": null,
    "_testcapi.get_date_fromdate": null,
    "_testcapi.get_date_fromtimestamp": null,
    "_testcapi.get_datetime_fromdateandtime": null,
    "_testcapi.get_datetime_fromdateandtimeandfold": null,
    "_testcapi.get_datetime_fromtimestamp": null,
    "_testcapi.get_delta_fromdsu": null,
    "_testcapi.get_kwargs": null,
    "_testcapi.get_mapping_items": null,
    "_testcapi.get_mapping_keys": null,
    "_testcapi.get_mapping_values": null,
    "_testcapi.get_time_fromtime": null,
    "_testcapi.get_time_fromtimeandfold": null,
    "_testcapi.get_timezone_utc_capi": null,
    "_testcapi.get_timezones_offset_zero": null,
    "_testcapi.getargs_B": null,
    "_testcapi.getargs_C": null,
    "_testcapi.getargs_D": null,
    "_testcapi.getargs_H": null,
    "_testcapi.getargs_I": null,
    "_testcapi.getargs_K": null,
    "_testcapi.getargs_L": null,
    "_testcapi.getargs_S": null,
    "_testcapi.getargs_U": null,
    "_testcapi.getargs_Y": null,
    "_testcapi.getargs_Z": null,
    "_testcapi.getargs_Z_hash": null,
    "_testcapi.getargs_b": null,
    "_testcapi.getargs_c": null,
    "_testcapi.getargs_d": null,
    "_testcapi.getargs_es": null,
    "_testcapi.getargs_es_hash": null,
    "_testcapi.getargs_et": null,
    "_testcapi.getargs_et_hash": null,
    "_testcapi.getargs_f": null,
    "_testcapi.getargs_h": null,
    "_testcapi.getargs_i": null,
    "_testcapi.getargs_k": null,
    "_testcapi.getargs_keyword_only": null,
    "_testcapi.getargs_keywords": null,
    "_testcapi.getargs_l": null,
    "_testcapi.getargs_n": null,
    "_testcapi.getargs_p": null,
    "_testcapi.getargs_positional_only_and_keywords": null,
    "_testcapi.getargs_s": null,
    "_testcapi.getargs_s_hash": null,
    "_testcapi.getargs_s_star": null,
    "_testcapi.getargs_tuple": null,
    "_testcapi.getargs_u": null,
    "_testcapi.getargs_u_hash": null,
    "_testcapi.getargs_w_star": null,
    "_testcapi.getargs_y": null,
    "_testcapi.getargs_y_hash": null,
    "_testcapi.getargs_y_star": null,
    "_testcapi.getargs_z": null,
    "_testcapi.getargs_z_hash": null,
    "_testcapi.getargs_z_star": null,
    "_testcapi.getbuffer_with_null_view": null,
    "_testcapi.hamt": null,
    "_testcapi.make_exception_with_doc": null,
    "_testcapi.make_memoryview_from_NULL_pointer": null,
    "_testcapi.make_timezones_capi": null,
    "_testcapi.meth_fastcall": null,
    "_testcapi.meth_fastcall_keywords": null,
    "_testcapi.meth_noargs": null,
    "_testcapi.meth_o": null,
    "_testcapi.meth_varargs": null,
    "_testcapi.meth_varargs_keywords": null,
    "_testcapi.no_docstring": null,
    "_testcapi.parse_tuple_and_keywords": null,
    "_testcapi.pymarshal_read_last_object_from_file": null,
    "_testcapi.pymarshal_read_long_from_file": null,
    "_testcapi.pymarshal_read_object_from_file": null,
    "_testcapi.pymarshal_read_short_from_file": null,
    "_testcapi.pymarshal_write_long_to_file": null,
    "_testcapi.pymarshal_write_object_to_file": null,
    "_testcapi.pymem_api_misuse": null,
    "_testcapi.pymem_buffer_overflow": null,
    "_testcapi.pymem_getallocatorsname": null,
    "_testcapi.pymem_malloc_without_gil": null,
    "_testcapi.pynumber_tobase": null,
    "_testcapi.pyobject_fastcall": null,
    "_testcapi.pyobject_fastcalldict": null,
    "_testcapi.pyobject_malloc_without_gil": null,
    "_testcapi.pyobject_vectorcall": null,
    "_testcapi.pytime_object_to_time_t": null,
    "_testcapi.pytime_object_to_timespec": null,
    "_testcapi.pytime_object_to_timeval": null,
    "_testcapi.pyvectorcall_call": null,
    "_testcapi.raise_SIGINT_then_send_None": null,
    "_testcapi.raise_exception": null,
    "_testcapi.raise_memoryerror": null,
    "_testcapi.remove_mem_hooks": "Remove memory hooks.",
    "_testcapi.return_null_without_error": null,
    "_testcapi.return_result_with_error": null,
    "_testcapi.run_in_subinterp": null,
    "_testcapi.sequence_getitem": null,
    "_testcapi.set_errno": null,
    "_testcapi.set_exc_info": null,
    "_testcapi.set_nomemory": "set_nomemory(start:int, stop:int = 0)",
    "_testcapi.stack_pointer": null,
    "_testcapi.test_L_code": null,
    "_testcapi.test_Z_code": null,
    "_testcapi.test_buildvalue_N": null,
    "_testcapi.test_buildvalue_issue38913": null,
    "_testcapi.test_capsule": null,
    "_testcapi.test_config": null,
    "_testcapi.test_datetime_capi": null,
    "_testcapi.test_decref_doesnt_leak": null,
    "_testcapi.test_dict_iteration": null,
    "_testcapi.test_empty_argparse": null,
    "_testcapi.test_from_contiguous": null,
    "_testcapi.test_incref_decref_API": null,
    "_testcapi.test_incref_doesnt_leak": null,
    "_testcapi.test_k_code": null,
    "_testcapi.test_lazy_hash_inheritance": null,
    "_testcapi.test_list_api": null,
    "_testcapi.test_long_and_overflow": null,
    "_testcapi.test_long_api": null,
    "_testcapi.test_long_as_double": null,
    "_testcapi.test_long_as_size_t": null,
    "_testcapi.test_long_as_unsigned_long_long_mask": null,
    "_testcapi.test_long_long_and_overflow": null,
    "_testcapi.test_long_numbits": null,
    "_testcapi.test_longlong_api": null,
    "_testcapi.test_null_strings": null,
    "_testcapi.test_pep3118_obsolete_write_locks": null,
    "_testcapi.test_pymem_alloc0": null,
    "_testcapi.test_pymem_setallocators": null,
    "_testcapi.test_pymem_setrawallocators": null,
    "_testcapi.test_pyobject_setallocators": null,
    "_testcapi.test_pythread_tss_key_state": null,
    "_testcapi.test_s_code": null,
    "_testcapi.test_sizeof_c_types": null,
    "_testcapi.test_string_from_format": null,
    "_testcapi.test_string_to_double": null,
    "_testcapi.test_structseq_newtype_doesnt_leak": null,
    "_testcapi.test_u_code": null,
    "_testcapi.test_unicode_compare_with_ascii": null,
    "_testcapi.test_widechar": null,
    "_testcapi.test_with_docstring": "This is a pretty normal docstring.",
    "_testcapi.test_xdecref_doesnt_leak": null,
    "_testcapi.test_xincref_doesnt_leak": null,
    "_testcapi.traceback_print": null,
    "_testcapi.tracemalloc_get_traceback": null,
    "_testcapi.tracemalloc_track": null,
    "_testcapi.tracemalloc_untrack": null,
    "_testcapi.unicode_asucs4": null,
    "_testcapi.unicode_asutf8": null,
    "_testcapi.unicode_asutf8andsize": null,
    "_testcapi.unicode_aswidechar": null,
    "_testcapi.unicode_aswidecharstring": null,
    "_testcapi.unicode_copycharacters": null,
    "_testcapi.unicode_encodedecimal": null,
    "_testcapi.unicode_findchar": null,
    "_testcapi.unicode_legacy_string": null,
    "_testcapi.unicode_transformdecimaltoascii": null,
    "_testcapi.with_tp_del": null,
    "_testcapi.without_gc": null,
    "_testcapi.write_unraisable_exc": null,
    "_testimportmultiple": "_testimportmultiple doc",
    "_testinternalcapi.get_configs": null,
    "_testinternalcapi.get_recursion_depth": null,
    "_testinternalcapi.test_bswap": null,
    "_testinternalcapi.test_hashtable": null,
    "_testmultiphase": "Test module main",
    "_testmultiphase.call_state_registration_func": "register_state(0): call PyState_FindModule()\nregister_state(1): call PyState_AddModule()\nregister_state(2): call PyState_RemoveModule()",
    "_testmultiphase.foo": "foo(i,j)\n\nReturn the sum of i and j.",
    "_thread": "This module provides primitive operations to write multi-threaded programs.\nThe 'threading' module provides a more convenient interface.",
    "_thread.LockType": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_thread.LockType.__subclasshook__": "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__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_thread.RLock.__subclasshook__": "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": "ExceptHookArgs\n\nType used to pass arguments to threading.excepthook.",
    "_thread._ExceptHookArgs.__class_getitem__": "See PEP 585",
    "_thread._ExceptHookArgs.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_thread._ExceptHookArgs.__subclasshook__": "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": "_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": "excepthook(exc_type, exc_value, exc_traceback, thread)\n\nHandle uncaught Thread.run() exception.",
    "_thread._local": "Thread-local data",
    "_thread._local.__init_subclass__": "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__": "Create and return a new object.  See help(type) for accurate signature.",
    "_thread._local.__subclasshook__": "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": "_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": "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": "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": "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": "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": "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": "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": "interrupt_main()\n\nRaise a KeyboardInterrupt in the main thread.\nA subthread can use this function to interrupt the main thread.",
    "_thread.stack_size": "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": "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": "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",
    "_tkinter.TclError.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_tkinter.TclError.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_tkinter.TclError.__subclasshook__": "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",
    "_tkinter.Tcl_Obj.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_tkinter.Tcl_Obj.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_tkinter.Tcl_Obj.__subclasshook__": "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",
    "_tkinter.TkappType.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_tkinter.TkappType.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_tkinter.TkappType.__subclasshook__": "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",
    "_tkinter.TkttType.__init_subclass__": "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.\n",
    "_tkinter.TkttType.__new__": "Create and return a new object.  See help(type) for accurate signature.",
    "_tkinter.TkttType.__subclasshook__": "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",
    "_tkinter._flatten": null,
    "_tkinter.create": "\n\n  wantTk\n    if false, then Tk_Init() doesn't get called\n  sync\n    if true, then pass -sync to wish\n  use\n    if not None, then pass -use to wish",
    "_tkinter.getbusywaitinterval": "Return the current busy-wait interval between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.",
    "_tkinter.setbusywaitinterval": "Set the busy-wait interval in milliseconds between successive calls to Tcl_DoOneEvent in a threaded Python interpreter.\n\nIt should be set to a divisor of the maximum time between frames in an animation.",
    "_tracemalloc": "Debug module to trace memory blocks allocated by Python.",
    "_tracemalloc._get_object_traceback": "Get the traceback where the Python object obj was allocated.\n\nReturn a tuple of (filename: str, lineno: int) tuples.\nReturn None if the tracemalloc module is disabled or did not\ntrace the allocation of the object.",
    "_tracemalloc._get_traces": "Get traces of all memory blocks allocated by Python.\n\nReturn a list of (size: int, traceback: tuple) tuples.\ntraceback is a tuple of (filename: str, lineno: int) tuples.\n\nReturn an empty list if the tracemalloc module is disabled.",
    "_tracemalloc.clear_traces": "Clear traces of memory blocks allocated by Python.",
    "_tracemalloc.get_traceback_limit": "Get the maximum number of frames stored in the traceback of a trace.\n\nBy default, a trace of an allocated memory block only stores\nthe most recent frame: the limit is 1.",
    "_tracemalloc.get_traced_memory": "Get the current size and peak size of memory blocks traced by tracemalloc.\n\nReturns a tuple: (current: int, peak: int).",
    "_tracemalloc.get_tracemalloc_memory": "Get the memory usage in bytes of the tracemalloc module.\n\nThis memory is used internally to trace memory allocations.",
    "_tracemalloc.is_tracing": "Return True if the tracemalloc module is tracing Python memory allocations.",
    "_tracemalloc.reset_peak": "Set the peak size of memory blocks traced by tracemalloc to the current size.\n\nDo nothing if the tracemalloc module is not tracing memory allocations.",
    "_tracemalloc.start": "Start tracing Python memory allocations.\n\nAlso set the maximum number of frames stored in the traceback of a\ntrace to nframe.",
    "_tracemalloc.stop": "Stop tracing Python memory allocations.\n\nAlso clear traces of memory blocks allocated by Python.",
    "_warnings": "_warnings provides basic warning filtering support.\nIt is a helper module to speed up interpreter start-up.",
    "_warnings._filters_mutated": null,
    "_warnings.warn": "Issue a warning, or maybe ignore it or raise an exception.",