From 3d0b809d2f3c1aed3318843a87d8120cc718d258 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Wed, 10 Dec 2025 17:16:48 +0900 Subject: [PATCH 1/3] Add types.* for doc/generate.py --- crates/doc/generate.py | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/crates/doc/generate.py b/crates/doc/generate.py index 2f553ac0a19..73cb462bb9f 100644 --- a/crates/doc/generate.py +++ b/crates/doc/generate.py @@ -194,6 +194,15 @@ def find_doc_entries() -> "Iterable[DocEntry]": type(str().__iter__()), type(tuple().__iter__()), ] + + # Add types from the types module (e.g., ModuleType, FunctionType, etc.) + for name in dir(types): + if name.startswith("_"): + continue + obj = getattr(types, name) + if isinstance(obj, type): + builtin_types.append(obj) + for typ in builtin_types: parts = ("builtins", typ.__name__) yield DocEntry(parts, pydoc._getowndoc(typ)) @@ -204,7 +213,7 @@ def main(): docs = { entry.key: entry.doc for entry in find_doc_entries() - if entry.raw_doc is not None + if entry.raw_doc is not None and isinstance(entry.raw_doc, str) } dumped = json.dumps(docs, sort_keys=True, indent=4) OUTPUT_FILE.write_text(dumped) From 2a16d6334553b50e8bf8a7a15699542f3725cb67 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Wed, 10 Dec 2025 17:25:56 +0900 Subject: [PATCH 2/3] udpate-doc-db workflow --- .github/workflows/update-doc-db.yml | 41 +++++++++++++++++++---------- 1 file changed, 27 insertions(+), 14 deletions(-) diff --git a/.github/workflows/update-doc-db.yml b/.github/workflows/update-doc-db.yml index 1376e844fd1..c53de5461eb 100644 --- a/.github/workflows/update-doc-db.yml +++ b/.github/workflows/update-doc-db.yml @@ -1,7 +1,7 @@ name: Update doc DB permissions: - contents: read + contents: write on: workflow_dispatch: @@ -10,11 +10,14 @@ on: description: Target python version to generate doc db for type: string default: "3.13.9" + ref: + description: Branch to commit to (leave empty for current branch) + type: string + default: "" defaults: run: shell: bash - working-directory: ./crates/rustpython-doc jobs: generate: @@ -30,19 +33,19 @@ jobs: with: persist-credentials: false sparse-checkout: | - crates/rustpython-doc + crates/doc - uses: actions/setup-python@83679a892e2d95755f2dac6acb0bfd1e9ac5d548 # v6.1.0 with: python-version: ${{ inputs.python-version }} - name: Generate docs - run: python ./generate.py + run: python crates/doc/generate.py - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: name: doc-db-${{ inputs.python-version }}-${{ matrix.os }} - path: "crates/rustpython-doc/generated/*.json" + path: "crates/doc/generated/*.json" if-no-files-found: error retention-days: 7 overwrite: true @@ -53,26 +56,25 @@ jobs: steps: - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1 with: - persist-credentials: false - sparse-checkout: | - crates/rustpython-doc + ref: ${{ inputs.ref || github.ref }} + token: ${{ secrets.AUTO_COMMIT_PAT }} - name: Download generated doc DBs uses: actions/download-artifact@018cc2cf5baa6db3ef3c5f8a56943fffe632ef53 # v6.0.0 with: pattern: "doc-db-${{ inputs.python-version }}-**" - path: crates/rustpython-doc/generated/ + path: crates/doc/generated/ merge-multiple: true - name: Transform JSON run: | # Merge all artifacts - jq -s "add" --sort-keys generated/*.json > generated/merged.json + jq -s "add" --sort-keys crates/doc/generated/*.json > crates/doc/generated/merged.json # Format merged json for the phf macro - jq -r 'to_entries[] | " \(.key | @json) => \(.value | @json),"' generated/merged.json > generated/raw_entries.txt + jq -r 'to_entries[] | " \(.key | @json) => \(.value | @json),"' crates/doc/generated/merged.json > crates/doc/generated/raw_entries.txt - OUTPUT_FILE='src/data.inc.rs' + OUTPUT_FILE='crates/doc/src/data.inc.rs' echo -n '' > $OUTPUT_FILE @@ -83,13 +85,24 @@ jobs: echo '' >> $OUTPUT_FILE echo "pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! {" >> $OUTPUT_FILE - cat generated/raw_entries.txt >> $OUTPUT_FILE + cat crates/doc/generated/raw_entries.txt >> $OUTPUT_FILE echo '};' >> $OUTPUT_FILE - uses: actions/upload-artifact@330a01c490aca151604b8cf639adc76d48f6c5d4 # v5.0.0 with: name: doc-db-${{ inputs.python-version }} - path: "crates/rustpython-doc/src/data.inc.rs" + path: "crates/doc/src/data.inc.rs" if-no-files-found: error retention-days: 7 overwrite: true + + - name: Commit and push (non-main branches only) + if: github.ref != 'refs/heads/main' && inputs.ref != 'main' + run: | + git config user.name "github-actions[bot]" + git config user.email "github-actions[bot]@users.noreply.github.com" + if [ -n "$(git status --porcelain)" ]; then + git add crates/doc/src/data.inc.rs + git commit -m "Update doc DB for CPython ${{ inputs.python-version }}" + git push + fi From b2367ac819d3d75c3a3d11bcf0b589b6248abc5d Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" Date: Wed, 10 Dec 2025 08:40:19 +0000 Subject: [PATCH 3/3] Update doc DB for CPython 3.13.9 --- crates/doc/src/data.inc.rs | 554 +++++++++++++++++++++++++++++++++++++ 1 file changed, 554 insertions(+) diff --git a/crates/doc/src/data.inc.rs b/crates/doc/src/data.inc.rs index ee08b59f7ba..4411587ca8b 100644 --- a/crates/doc/src/data.inc.rs +++ b/crates/doc/src/data.inc.rs @@ -4050,6 +4050,28 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.DeprecationWarning.__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).", "builtins.DeprecationWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception", "builtins.DeprecationWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.", + "builtins.DynamicClassAttribute" => "Route attribute access on a class to __getattr__.\n\nThis is a descriptor, used to define attributes that act differently when\naccessed through an instance and through a class. Instance access remains\nnormal, but access to an attribute through a class will be routed to the\nclass's __getattr__ method; this is done by raising AttributeError.\n\nThis allows one to have properties active on an instance, and have virtual\nattributes on the class with the same name. (Enum used this between Python\nversions 3.4 - 3.9 .)\n\nSubclass from this to use a different method of accessing virtual attributes\nand still be treated properly by the inspect module. (Enum uses this since\nPython 3.10 .)", + "builtins.DynamicClassAttribute.__delattr__" => "Implement delattr(self, name).", + "builtins.DynamicClassAttribute.__eq__" => "Return self==value.", + "builtins.DynamicClassAttribute.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.DynamicClassAttribute.__ge__" => "Return self>=value.", + "builtins.DynamicClassAttribute.__getattribute__" => "Return getattr(self, name).", + "builtins.DynamicClassAttribute.__getstate__" => "Helper for pickle.", + "builtins.DynamicClassAttribute.__gt__" => "Return self>value.", + "builtins.DynamicClassAttribute.__hash__" => "Return hash(self).", + "builtins.DynamicClassAttribute.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.DynamicClassAttribute.__le__" => "Return self<=value.", + "builtins.DynamicClassAttribute.__lt__" => "Return self "Return self!=value.", + "builtins.DynamicClassAttribute.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.DynamicClassAttribute.__reduce__" => "Helper for pickle.", + "builtins.DynamicClassAttribute.__reduce_ex__" => "Helper for pickle.", + "builtins.DynamicClassAttribute.__repr__" => "Return repr(self).", + "builtins.DynamicClassAttribute.__setattr__" => "Implement setattr(self, name, value).", + "builtins.DynamicClassAttribute.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.DynamicClassAttribute.__str__" => "Return str(self).", + "builtins.DynamicClassAttribute.__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).", + "builtins.DynamicClassAttribute.__weakref__" => "list of weak references to the object", "builtins.EOFError" => "Read beyond end of file.", "builtins.EOFError.__cause__" => "exception cause", "builtins.EOFError.__context__" => "exception context", @@ -4318,6 +4340,33 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.GeneratorExit.__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).", "builtins.GeneratorExit.add_note" => "Exception.add_note(note) --\nadd a note to the exception", "builtins.GeneratorExit.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.", + "builtins.GenericAlias" => "Represent a PEP 585 generic type\n\nE.g. for t = list[int], t.__origin__ is list and t.__args__ is (int,).", + "builtins.GenericAlias.__call__" => "Call self as a function.", + "builtins.GenericAlias.__delattr__" => "Implement delattr(self, name).", + "builtins.GenericAlias.__eq__" => "Return self==value.", + "builtins.GenericAlias.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.GenericAlias.__ge__" => "Return self>=value.", + "builtins.GenericAlias.__getattribute__" => "Return getattr(self, name).", + "builtins.GenericAlias.__getitem__" => "Return self[key].", + "builtins.GenericAlias.__getstate__" => "Helper for pickle.", + "builtins.GenericAlias.__gt__" => "Return self>value.", + "builtins.GenericAlias.__hash__" => "Return hash(self).", + "builtins.GenericAlias.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.GenericAlias.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.GenericAlias.__iter__" => "Implement iter(self).", + "builtins.GenericAlias.__le__" => "Return self<=value.", + "builtins.GenericAlias.__lt__" => "Return self "Return self!=value.", + "builtins.GenericAlias.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.GenericAlias.__or__" => "Return self|value.", + "builtins.GenericAlias.__parameters__" => "Type variables in the GenericAlias.", + "builtins.GenericAlias.__reduce_ex__" => "Helper for pickle.", + "builtins.GenericAlias.__repr__" => "Return repr(self).", + "builtins.GenericAlias.__ror__" => "Return value|self.", + "builtins.GenericAlias.__setattr__" => "Implement setattr(self, name, value).", + "builtins.GenericAlias.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.GenericAlias.__str__" => "Return str(self).", + "builtins.GenericAlias.__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).", "builtins.IOError" => "Base class for I/O related errors.", "builtins.IOError.__cause__" => "exception cause", "builtins.IOError.__context__" => "exception context", @@ -4753,6 +4802,28 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.NotImplementedError.__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).", "builtins.NotImplementedError.add_note" => "Exception.add_note(note) --\nadd a note to the exception", "builtins.NotImplementedError.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.", + "builtins.NotImplementedType" => "The type of the NotImplemented singleton.", + "builtins.NotImplementedType.__bool__" => "True if self else False", + "builtins.NotImplementedType.__delattr__" => "Implement delattr(self, name).", + "builtins.NotImplementedType.__eq__" => "Return self==value.", + "builtins.NotImplementedType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.NotImplementedType.__ge__" => "Return self>=value.", + "builtins.NotImplementedType.__getattribute__" => "Return getattr(self, name).", + "builtins.NotImplementedType.__getstate__" => "Helper for pickle.", + "builtins.NotImplementedType.__gt__" => "Return self>value.", + "builtins.NotImplementedType.__hash__" => "Return hash(self).", + "builtins.NotImplementedType.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.NotImplementedType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.NotImplementedType.__le__" => "Return self<=value.", + "builtins.NotImplementedType.__lt__" => "Return self "Return self!=value.", + "builtins.NotImplementedType.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.NotImplementedType.__reduce_ex__" => "Helper for pickle.", + "builtins.NotImplementedType.__repr__" => "Return repr(self).", + "builtins.NotImplementedType.__setattr__" => "Implement setattr(self, name, value).", + "builtins.NotImplementedType.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.NotImplementedType.__str__" => "Return str(self).", + "builtins.NotImplementedType.__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).", "builtins.OSError" => "Base class for I/O related errors.", "builtins.OSError.__cause__" => "exception cause", "builtins.OSError.__context__" => "exception context", @@ -5043,6 +5114,28 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.RuntimeWarning.__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).", "builtins.RuntimeWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception", "builtins.RuntimeWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.", + "builtins.SimpleNamespace" => "A simple attribute-based namespace.", + "builtins.SimpleNamespace.__delattr__" => "Implement delattr(self, name).", + "builtins.SimpleNamespace.__eq__" => "Return self==value.", + "builtins.SimpleNamespace.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.SimpleNamespace.__ge__" => "Return self>=value.", + "builtins.SimpleNamespace.__getattribute__" => "Return getattr(self, name).", + "builtins.SimpleNamespace.__getstate__" => "Helper for pickle.", + "builtins.SimpleNamespace.__gt__" => "Return self>value.", + "builtins.SimpleNamespace.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.SimpleNamespace.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.SimpleNamespace.__le__" => "Return self<=value.", + "builtins.SimpleNamespace.__lt__" => "Return self "Return self!=value.", + "builtins.SimpleNamespace.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.SimpleNamespace.__reduce__" => "Return state information for pickling", + "builtins.SimpleNamespace.__reduce_ex__" => "Helper for pickle.", + "builtins.SimpleNamespace.__replace__" => "Return a copy of the namespace object with new values for the specified attributes.", + "builtins.SimpleNamespace.__repr__" => "Return repr(self).", + "builtins.SimpleNamespace.__setattr__" => "Implement setattr(self, name, value).", + "builtins.SimpleNamespace.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.SimpleNamespace.__str__" => "Return str(self).", + "builtins.SimpleNamespace.__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).", "builtins.StopAsyncIteration" => "Signal the end from iterator.__anext__().", "builtins.StopAsyncIteration.__cause__" => "exception cause", "builtins.StopAsyncIteration.__context__" => "exception context", @@ -5457,6 +5550,32 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.UnicodeWarning.__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).", "builtins.UnicodeWarning.add_note" => "Exception.add_note(note) --\nadd a note to the exception", "builtins.UnicodeWarning.with_traceback" => "Exception.with_traceback(tb) --\nset self.__traceback__ to tb and return self.", + "builtins.UnionType" => "Represent a PEP 604 union type\n\nE.g. for int | str", + "builtins.UnionType.__delattr__" => "Implement delattr(self, name).", + "builtins.UnionType.__eq__" => "Return self==value.", + "builtins.UnionType.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.UnionType.__ge__" => "Return self>=value.", + "builtins.UnionType.__getattribute__" => "Return getattr(self, name).", + "builtins.UnionType.__getitem__" => "Return self[key].", + "builtins.UnionType.__getstate__" => "Helper for pickle.", + "builtins.UnionType.__gt__" => "Return self>value.", + "builtins.UnionType.__hash__" => "Return hash(self).", + "builtins.UnionType.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.UnionType.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.UnionType.__le__" => "Return self<=value.", + "builtins.UnionType.__lt__" => "Return self "Return self!=value.", + "builtins.UnionType.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.UnionType.__or__" => "Return self|value.", + "builtins.UnionType.__parameters__" => "Type variables in the types.UnionType.", + "builtins.UnionType.__reduce__" => "Helper for pickle.", + "builtins.UnionType.__reduce_ex__" => "Helper for pickle.", + "builtins.UnionType.__repr__" => "Return repr(self).", + "builtins.UnionType.__ror__" => "Return value|self.", + "builtins.UnionType.__setattr__" => "Implement setattr(self, name, value).", + "builtins.UnionType.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.UnionType.__str__" => "Return str(self).", + "builtins.UnionType.__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).", "builtins.UserWarning" => "Base class for warnings generated by user code.", "builtins.UserWarning.__cause__" => "exception cause", "builtins.UserWarning.__context__" => "exception context", @@ -5628,6 +5747,35 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.anext" => "Return the next item from the async iterator.\n\nIf default is given and the async iterator is exhausted,\nit is returned instead of raising StopAsyncIteration.", "builtins.any" => "Return True if bool(x) is True for any x in the iterable.\n\nIf the iterable is empty, return False.", "builtins.ascii" => "Return an ASCII-only representation of an object.\n\nAs repr(), return a string containing a printable representation of an\nobject, but escape the non-ASCII characters in the string returned by\nrepr() using \\\\x, \\\\u or \\\\U escapes. This generates a string similar\nto that returned by repr() in Python 2.", + "builtins.async_generator.__aiter__" => "Return an awaitable, that resolves in asynchronous iterator.", + "builtins.async_generator.__anext__" => "Return a value or raise StopAsyncIteration.", + "builtins.async_generator.__class_getitem__" => "See PEP 585", + "builtins.async_generator.__del__" => "Called when the instance is about to be destroyed.", + "builtins.async_generator.__delattr__" => "Implement delattr(self, name).", + "builtins.async_generator.__eq__" => "Return self==value.", + "builtins.async_generator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.async_generator.__ge__" => "Return self>=value.", + "builtins.async_generator.__getattribute__" => "Return getattr(self, name).", + "builtins.async_generator.__getstate__" => "Helper for pickle.", + "builtins.async_generator.__gt__" => "Return self>value.", + "builtins.async_generator.__hash__" => "Return hash(self).", + "builtins.async_generator.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.async_generator.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.async_generator.__le__" => "Return self<=value.", + "builtins.async_generator.__lt__" => "Return self "Return self!=value.", + "builtins.async_generator.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.async_generator.__reduce__" => "Helper for pickle.", + "builtins.async_generator.__reduce_ex__" => "Helper for pickle.", + "builtins.async_generator.__repr__" => "Return repr(self).", + "builtins.async_generator.__setattr__" => "Implement setattr(self, name, value).", + "builtins.async_generator.__sizeof__" => "gen.__sizeof__() -> size of gen in memory, in bytes", + "builtins.async_generator.__str__" => "Return str(self).", + "builtins.async_generator.__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).", + "builtins.async_generator.aclose" => "aclose() -> raise GeneratorExit inside generator.", + "builtins.async_generator.ag_await" => "object being awaited on, or None", + "builtins.async_generator.asend" => "asend(v) -> send 'v' in generator.", + "builtins.async_generator.athrow" => "athrow(value)\nathrow(type[,value[,tb]])\n\nraise exception in generator.\nthe (type, val, tb) signature is deprecated, \nand may be removed in a future version of Python.", "builtins.bin" => "Return the binary representation of an integer.\n\n>>> bin(2796202)\n'0b1010101010101010101010'", "builtins.bool" => "Returns True when the argument is true, False otherwise.\nThe builtins True and False are the only two instances of the class bool.\nThe class bool is a subclass of the class int, and cannot be subclassed.", "builtins.bool.__abs__" => "abs(self)", @@ -5701,6 +5849,27 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.bool.real" => "the real part of a complex number", "builtins.bool.to_bytes" => "Return an array of bytes representing an integer.\n\nlength\n Length of bytes object to use. An OverflowError is raised if the\n integer is not representable with the given number of bytes. Default\n is length 1.\nbyteorder\n The byte order used to represent the integer. If byteorder is 'big',\n the most significant byte is at the beginning of the byte array. If\n byteorder is 'little', the most significant byte is at the end of the\n byte array. To request the native byte order of the host system, use\n sys.byteorder as the byte order value. Default is to use 'big'.\nsigned\n Determines whether two's complement is used to represent the integer.\n If signed is False and a negative integer is given, an OverflowError\n is raised.", "builtins.breakpoint" => "Call sys.breakpointhook(*args, **kws). sys.breakpointhook() must accept\nwhatever arguments are passed.\n\nBy default, this drops you into the pdb debugger.", + "builtins.builtin_function_or_method.__call__" => "Call self as a function.", + "builtins.builtin_function_or_method.__delattr__" => "Implement delattr(self, name).", + "builtins.builtin_function_or_method.__eq__" => "Return self==value.", + "builtins.builtin_function_or_method.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.builtin_function_or_method.__ge__" => "Return self>=value.", + "builtins.builtin_function_or_method.__getattribute__" => "Return getattr(self, name).", + "builtins.builtin_function_or_method.__getstate__" => "Helper for pickle.", + "builtins.builtin_function_or_method.__gt__" => "Return self>value.", + "builtins.builtin_function_or_method.__hash__" => "Return hash(self).", + "builtins.builtin_function_or_method.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.builtin_function_or_method.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.builtin_function_or_method.__le__" => "Return self<=value.", + "builtins.builtin_function_or_method.__lt__" => "Return self "Return self!=value.", + "builtins.builtin_function_or_method.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.builtin_function_or_method.__reduce_ex__" => "Helper for pickle.", + "builtins.builtin_function_or_method.__repr__" => "Return repr(self).", + "builtins.builtin_function_or_method.__setattr__" => "Implement setattr(self, name, value).", + "builtins.builtin_function_or_method.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.builtin_function_or_method.__str__" => "Return str(self).", + "builtins.builtin_function_or_method.__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).", "builtins.bytearray" => "bytearray(iterable_of_ints) -> bytearray\nbytearray(string, encoding[, errors]) -> bytearray\nbytearray(bytes_or_buffer) -> mutable copy of bytes_or_buffer\nbytearray(int) -> bytes array of size given by the parameter initialized with null bytes\nbytearray() -> empty bytes array\n\nConstruct a mutable bytearray object from:\n - an iterable yielding integers in range(256)\n - a text string encoded using the specified encoding\n - a bytes or a buffer object\n - any object implementing the buffer API.\n - an integer", "builtins.bytearray.__add__" => "Return self+value.", "builtins.bytearray.__alloc__" => "B.__alloc__() -> int\n\nReturn the number of bytes actually allocated.", @@ -5914,6 +6083,27 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.bytes_iterator.__str__" => "Return str(self).", "builtins.bytes_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).", "builtins.callable" => "Return whether the object is callable (i.e., some kind of function).\n\nNote that classes are callable, as are instances of classes with a\n__call__() method.", + "builtins.cell" => "Create a new cell object.\n\n contents\n the contents of the cell. If not specified, the cell will be empty,\n and \nfurther attempts to access its cell_contents attribute will\n raise a ValueError.", + "builtins.cell.__delattr__" => "Implement delattr(self, name).", + "builtins.cell.__eq__" => "Return self==value.", + "builtins.cell.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.cell.__ge__" => "Return self>=value.", + "builtins.cell.__getattribute__" => "Return getattr(self, name).", + "builtins.cell.__getstate__" => "Helper for pickle.", + "builtins.cell.__gt__" => "Return self>value.", + "builtins.cell.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.cell.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.cell.__le__" => "Return self<=value.", + "builtins.cell.__lt__" => "Return self "Return self!=value.", + "builtins.cell.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.cell.__reduce__" => "Helper for pickle.", + "builtins.cell.__reduce_ex__" => "Helper for pickle.", + "builtins.cell.__repr__" => "Return repr(self).", + "builtins.cell.__setattr__" => "Implement setattr(self, name, value).", + "builtins.cell.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.cell.__str__" => "Return str(self).", + "builtins.cell.__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).", "builtins.chr" => "Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.", "builtins.classmethod" => "Convert a function to be a class method.\n\nA class method receives the class as implicit first argument,\njust like an instance method receives the instance.\nTo declare a class method, use this idiom:\n\n class C:\n @classmethod\n def f(cls, arg1, arg2, argN):\n ...\n\nIt can be called either on the class (e.g. C.f()) or on an instance\n(e.g. C().f()). The instance is ignored except for its class.\nIf a class method is called for a derived class, the derived class\nobject is passed as the implied first argument.\n\nClass methods are different than C++ or Java static methods.\nIf you want those, see the staticmethod builtin.", "builtins.classmethod.__delattr__" => "Implement delattr(self, name).", @@ -5938,6 +6128,53 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.classmethod.__sizeof__" => "Size of object in memory, in bytes.", "builtins.classmethod.__str__" => "Return str(self).", "builtins.classmethod.__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).", + "builtins.classmethod_descriptor.__call__" => "Call self as a function.", + "builtins.classmethod_descriptor.__delattr__" => "Implement delattr(self, name).", + "builtins.classmethod_descriptor.__eq__" => "Return self==value.", + "builtins.classmethod_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.classmethod_descriptor.__ge__" => "Return self>=value.", + "builtins.classmethod_descriptor.__get__" => "Return an attribute of instance, which is of type owner.", + "builtins.classmethod_descriptor.__getattribute__" => "Return getattr(self, name).", + "builtins.classmethod_descriptor.__getstate__" => "Helper for pickle.", + "builtins.classmethod_descriptor.__gt__" => "Return self>value.", + "builtins.classmethod_descriptor.__hash__" => "Return hash(self).", + "builtins.classmethod_descriptor.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.classmethod_descriptor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.classmethod_descriptor.__le__" => "Return self<=value.", + "builtins.classmethod_descriptor.__lt__" => "Return self "Return self!=value.", + "builtins.classmethod_descriptor.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.classmethod_descriptor.__reduce__" => "Helper for pickle.", + "builtins.classmethod_descriptor.__reduce_ex__" => "Helper for pickle.", + "builtins.classmethod_descriptor.__repr__" => "Return repr(self).", + "builtins.classmethod_descriptor.__setattr__" => "Implement setattr(self, name, value).", + "builtins.classmethod_descriptor.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.classmethod_descriptor.__str__" => "Return str(self).", + "builtins.classmethod_descriptor.__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).", + "builtins.code" => "Create a code object. Not for the faint of heart.", + "builtins.code.__delattr__" => "Implement delattr(self, name).", + "builtins.code.__eq__" => "Return self==value.", + "builtins.code.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.code.__ge__" => "Return self>=value.", + "builtins.code.__getattribute__" => "Return getattr(self, name).", + "builtins.code.__getstate__" => "Helper for pickle.", + "builtins.code.__gt__" => "Return self>value.", + "builtins.code.__hash__" => "Return hash(self).", + "builtins.code.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.code.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.code.__le__" => "Return self<=value.", + "builtins.code.__lt__" => "Return self "Return self!=value.", + "builtins.code.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.code.__reduce__" => "Helper for pickle.", + "builtins.code.__reduce_ex__" => "Helper for pickle.", + "builtins.code.__replace__" => "The same as replace().", + "builtins.code.__repr__" => "Return repr(self).", + "builtins.code.__setattr__" => "Implement setattr(self, name, value).", + "builtins.code.__str__" => "Return str(self).", + "builtins.code.__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).", + "builtins.code._varname_from_oparg" => "(internal-only) Return the local variable name for the given oparg.\n\nWARNING: this method is for internal use only and may change or go away.", + "builtins.code.replace" => "Return a copy of the code object with new values for the specified fields.", "builtins.compile" => "Compile source into a code object that can be executed by exec() or eval().\n\nThe source code may represent a Python module, statement or expression.\nThe filename will be used for run-time error messages.\nThe mode must be 'exec' to compile a module, 'single' to compile a\nsingle (interactive) statement, or 'eval' to compile an expression.\nThe flags argument, if present, controls which future statements influence\nthe compilation of the code.\nThe dont_inherit argument, if true, stops the compilation inheriting\nthe effects of any future statements in effect in the code calling\ncompile; if absent or false these statements do influence the compilation,\nin addition to any features explicitly specified.", "builtins.complex" => "Create a complex number from a string or numbers.\n\nIf a string is given, parse it as a complex number.\nIf a single number is given, convert it to a complex number.\nIf the 'real' or 'imag' arguments are given, create a complex number\nwith the specified real and imaginary components.", "builtins.complex.__abs__" => "abs(self)", @@ -5979,6 +6216,34 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.complex.conjugate" => "Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.", "builtins.complex.imag" => "the imaginary part of a complex number", "builtins.complex.real" => "the real part of a complex number", + "builtins.coroutine.__await__" => "Return an iterator to be used in await expression.", + "builtins.coroutine.__class_getitem__" => "See PEP 585", + "builtins.coroutine.__del__" => "Called when the instance is about to be destroyed.", + "builtins.coroutine.__delattr__" => "Implement delattr(self, name).", + "builtins.coroutine.__eq__" => "Return self==value.", + "builtins.coroutine.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.coroutine.__ge__" => "Return self>=value.", + "builtins.coroutine.__getattribute__" => "Return getattr(self, name).", + "builtins.coroutine.__getstate__" => "Helper for pickle.", + "builtins.coroutine.__gt__" => "Return self>value.", + "builtins.coroutine.__hash__" => "Return hash(self).", + "builtins.coroutine.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.coroutine.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.coroutine.__le__" => "Return self<=value.", + "builtins.coroutine.__lt__" => "Return self "Return self!=value.", + "builtins.coroutine.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.coroutine.__reduce__" => "Helper for pickle.", + "builtins.coroutine.__reduce_ex__" => "Helper for pickle.", + "builtins.coroutine.__repr__" => "Return repr(self).", + "builtins.coroutine.__setattr__" => "Implement setattr(self, name, value).", + "builtins.coroutine.__sizeof__" => "gen.__sizeof__() -> size of gen in memory, in bytes", + "builtins.coroutine.__str__" => "Return str(self).", + "builtins.coroutine.__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).", + "builtins.coroutine.close" => "close() -> raise GeneratorExit inside coroutine.", + "builtins.coroutine.cr_await" => "object being awaited on, or None", + "builtins.coroutine.send" => "send(arg) -> send 'arg' into coroutine,\nreturn next iterated value or raise StopIteration.", + "builtins.coroutine.throw" => "throw(value)\nthrow(type[,value[,traceback]])\n\nRaise exception in coroutine, return next iterated value or raise\nStopIteration.\nthe (type, val, tb) signature is deprecated, \nand may be removed in a future version of Python.", "builtins.delattr" => "Deletes the named attribute from the given object.\n\ndelattr(x, 'y') is equivalent to ``del x.y``", "builtins.dict" => "dict() -> new empty dictionary\ndict(mapping) -> new dictionary initialized from a mapping object's\n (key, value) pairs\ndict(iterable) -> new dictionary initialized as if via:\n d = {}\n for k, v in iterable:\n d[k] = v\ndict(**kwargs) -> new dictionary initialized with the name=value pairs\n in the keyword argument list. For example: dict(one=1, two=2)", "builtins.dict.__class_getitem__" => "See PEP 585", @@ -6156,6 +6421,27 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.dict_values.mapping" => "dictionary that this view refers to", "builtins.dir" => "dir([object]) -> list of strings\n\nIf called without an argument, return the names in the current scope.\nElse, return an alphabetized list of names comprising (some of) the attributes\nof the given object, and of attributes reachable from it.\nIf the object supplies a method named __dir__, it will be used; otherwise\nthe default dir() logic is used and returns:\n for a module object: the module's attributes.\n for a class object: its attributes, and recursively the attributes\n of its bases.\n for any other object: its attributes, its class's attributes, and\n recursively the attributes of its class's base classes.", "builtins.divmod" => "Return the tuple (x//y, x%y). Invariant: div*y + mod == x.", + "builtins.ellipsis" => "The type of the Ellipsis singleton.", + "builtins.ellipsis.__delattr__" => "Implement delattr(self, name).", + "builtins.ellipsis.__eq__" => "Return self==value.", + "builtins.ellipsis.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.ellipsis.__ge__" => "Return self>=value.", + "builtins.ellipsis.__getattribute__" => "Return getattr(self, name).", + "builtins.ellipsis.__getstate__" => "Helper for pickle.", + "builtins.ellipsis.__gt__" => "Return self>value.", + "builtins.ellipsis.__hash__" => "Return hash(self).", + "builtins.ellipsis.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.ellipsis.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.ellipsis.__le__" => "Return self<=value.", + "builtins.ellipsis.__lt__" => "Return self "Return self!=value.", + "builtins.ellipsis.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.ellipsis.__reduce_ex__" => "Helper for pickle.", + "builtins.ellipsis.__repr__" => "Return repr(self).", + "builtins.ellipsis.__setattr__" => "Implement setattr(self, name, value).", + "builtins.ellipsis.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.ellipsis.__str__" => "Return str(self).", + "builtins.ellipsis.__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).", "builtins.enumerate" => "Return an enumerate object.\n\n iterable\n an object supporting iteration\n\nThe enumerate object yields pairs containing a count (from start, which\ndefaults to zero) and a value yielded by the iterable argument.\n\nenumerate is useful for obtaining an indexed list:\n (0, seq[0]), (1, seq[1]), (2, seq[2]), ...", "builtins.enumerate.__class_getitem__" => "See PEP 585", "builtins.enumerate.__delattr__" => "Implement delattr(self, name).", @@ -6264,6 +6550,28 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.float.is_integer" => "Return True if the float is an integer.", "builtins.float.real" => "the real part of a complex number", "builtins.format" => "Return type(value).__format__(value, format_spec)\n\nMany built-in types implement format_spec according to the\nFormat Specification Mini-language. See help('FORMATTING').\n\nIf type(value) does not supply a method named __format__\nand format_spec is empty, then str(value) is returned.\nSee also help('SPECIALMETHODS').", + "builtins.frame.__delattr__" => "Implement delattr(self, name).", + "builtins.frame.__eq__" => "Return self==value.", + "builtins.frame.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.frame.__ge__" => "Return self>=value.", + "builtins.frame.__getattribute__" => "Return getattr(self, name).", + "builtins.frame.__getstate__" => "Helper for pickle.", + "builtins.frame.__gt__" => "Return self>value.", + "builtins.frame.__hash__" => "Return hash(self).", + "builtins.frame.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.frame.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.frame.__le__" => "Return self<=value.", + "builtins.frame.__lt__" => "Return self "Return self!=value.", + "builtins.frame.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.frame.__reduce__" => "Helper for pickle.", + "builtins.frame.__reduce_ex__" => "Helper for pickle.", + "builtins.frame.__repr__" => "Return repr(self).", + "builtins.frame.__setattr__" => "Implement setattr(self, name, value).", + "builtins.frame.__sizeof__" => "F.__sizeof__() -> size of F in memory, in bytes", + "builtins.frame.__str__" => "Return str(self).", + "builtins.frame.__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).", + "builtins.frame.clear" => "F.clear(): clear most references held by the frame", "builtins.frozenset" => "Build an immutable unordered collection of unique elements.", "builtins.frozenset.__and__" => "Return self&value.", "builtins.frozenset.__class_getitem__" => "See PEP 585", @@ -6331,7 +6639,60 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.function.__str__" => "Return str(self).", "builtins.function.__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).", "builtins.function.__type_params__" => "Get the declared type parameters for a function.", + "builtins.generator.__class_getitem__" => "See PEP 585", + "builtins.generator.__del__" => "Called when the instance is about to be destroyed.", + "builtins.generator.__delattr__" => "Implement delattr(self, name).", + "builtins.generator.__eq__" => "Return self==value.", + "builtins.generator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.generator.__ge__" => "Return self>=value.", + "builtins.generator.__getattribute__" => "Return getattr(self, name).", + "builtins.generator.__getstate__" => "Helper for pickle.", + "builtins.generator.__gt__" => "Return self>value.", + "builtins.generator.__hash__" => "Return hash(self).", + "builtins.generator.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.generator.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.generator.__iter__" => "Implement iter(self).", + "builtins.generator.__le__" => "Return self<=value.", + "builtins.generator.__lt__" => "Return self "Return self!=value.", + "builtins.generator.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.generator.__next__" => "Implement next(self).", + "builtins.generator.__reduce__" => "Helper for pickle.", + "builtins.generator.__reduce_ex__" => "Helper for pickle.", + "builtins.generator.__repr__" => "Return repr(self).", + "builtins.generator.__setattr__" => "Implement setattr(self, name, value).", + "builtins.generator.__sizeof__" => "gen.__sizeof__() -> size of gen in memory, in bytes", + "builtins.generator.__str__" => "Return str(self).", + "builtins.generator.__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).", + "builtins.generator.close" => "close() -> raise GeneratorExit inside generator.", + "builtins.generator.gi_yieldfrom" => "object being iterated by yield from, or None", + "builtins.generator.send" => "send(value) -> send 'value' into generator,\nreturn next yielded value or raise StopIteration.", + "builtins.generator.throw" => "throw(value)\nthrow(type[,value[,tb]])\n\nRaise exception in generator, return next yielded value or raise\nStopIteration.\nthe (type, val, tb) signature is deprecated, \nand may be removed in a future version of Python.", "builtins.getattr" => "getattr(object, name[, default]) -> value\n\nGet a named attribute from an object; getattr(x, 'y') is equivalent to x.y.\nWhen a default argument is given, it is returned when the attribute doesn't\nexist; without it, an exception is raised in that case.", + "builtins.getset_descriptor.__delattr__" => "Implement delattr(self, name).", + "builtins.getset_descriptor.__delete__" => "Delete an attribute of instance.", + "builtins.getset_descriptor.__eq__" => "Return self==value.", + "builtins.getset_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.getset_descriptor.__ge__" => "Return self>=value.", + "builtins.getset_descriptor.__get__" => "Return an attribute of instance, which is of type owner.", + "builtins.getset_descriptor.__getattribute__" => "Return getattr(self, name).", + "builtins.getset_descriptor.__getstate__" => "Helper for pickle.", + "builtins.getset_descriptor.__gt__" => "Return self>value.", + "builtins.getset_descriptor.__hash__" => "Return hash(self).", + "builtins.getset_descriptor.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.getset_descriptor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.getset_descriptor.__le__" => "Return self<=value.", + "builtins.getset_descriptor.__lt__" => "Return self "Return self!=value.", + "builtins.getset_descriptor.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.getset_descriptor.__reduce__" => "Helper for pickle.", + "builtins.getset_descriptor.__reduce_ex__" => "Helper for pickle.", + "builtins.getset_descriptor.__repr__" => "Return repr(self).", + "builtins.getset_descriptor.__set__" => "Set an attribute of instance to value.", + "builtins.getset_descriptor.__setattr__" => "Implement setattr(self, name, value).", + "builtins.getset_descriptor.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.getset_descriptor.__str__" => "Return str(self).", + "builtins.getset_descriptor.__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).", "builtins.globals" => "Return the dictionary containing the current scope's global variables.\n\nNOTE: Updates to this dictionary *will* affect name lookups in the current\nglobal scope and vice-versa.", "builtins.hasattr" => "Return whether the object has an attribute with the given name.\n\nThis is done by calling getattr(obj, name) and catching AttributeError.", "builtins.hash" => "Return the hash value for the given object.\n\nTwo objects that compare equal must also have the same hash value, but the\nreverse is not necessarily true.", @@ -6508,7 +6869,66 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.map.__sizeof__" => "Size of object in memory, in bytes.", "builtins.map.__str__" => "Return str(self).", "builtins.map.__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).", + "builtins.mappingproxy" => "Read-only proxy of a mapping.", + "builtins.mappingproxy.__class_getitem__" => "See PEP 585", + "builtins.mappingproxy.__contains__" => "Return bool(key in self).", + "builtins.mappingproxy.__delattr__" => "Implement delattr(self, name).", + "builtins.mappingproxy.__eq__" => "Return self==value.", + "builtins.mappingproxy.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.mappingproxy.__ge__" => "Return self>=value.", + "builtins.mappingproxy.__getattribute__" => "Return getattr(self, name).", + "builtins.mappingproxy.__getitem__" => "Return self[key].", + "builtins.mappingproxy.__getstate__" => "Helper for pickle.", + "builtins.mappingproxy.__gt__" => "Return self>value.", + "builtins.mappingproxy.__hash__" => "Return hash(self).", + "builtins.mappingproxy.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.mappingproxy.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.mappingproxy.__ior__" => "Return self|=value.", + "builtins.mappingproxy.__iter__" => "Implement iter(self).", + "builtins.mappingproxy.__le__" => "Return self<=value.", + "builtins.mappingproxy.__len__" => "Return len(self).", + "builtins.mappingproxy.__lt__" => "Return self "Return self!=value.", + "builtins.mappingproxy.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.mappingproxy.__or__" => "Return self|value.", + "builtins.mappingproxy.__reduce__" => "Helper for pickle.", + "builtins.mappingproxy.__reduce_ex__" => "Helper for pickle.", + "builtins.mappingproxy.__repr__" => "Return repr(self).", + "builtins.mappingproxy.__reversed__" => "D.__reversed__() -> reverse iterator", + "builtins.mappingproxy.__ror__" => "Return value|self.", + "builtins.mappingproxy.__setattr__" => "Implement setattr(self, name, value).", + "builtins.mappingproxy.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.mappingproxy.__str__" => "Return str(self).", + "builtins.mappingproxy.__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).", + "builtins.mappingproxy.copy" => "D.copy() -> a shallow copy of D", + "builtins.mappingproxy.get" => "Return the value for key if key is in the mapping, else default.", + "builtins.mappingproxy.items" => "D.items() -> a set-like object providing a view on D's items", + "builtins.mappingproxy.keys" => "D.keys() -> a set-like object providing a view on D's keys", + "builtins.mappingproxy.values" => "D.values() -> an object providing a view on D's values", "builtins.max" => "max(iterable, *[, default=obj, key=func]) -> value\nmax(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its biggest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more positional arguments, return the largest argument.", + "builtins.member_descriptor.__delattr__" => "Implement delattr(self, name).", + "builtins.member_descriptor.__delete__" => "Delete an attribute of instance.", + "builtins.member_descriptor.__eq__" => "Return self==value.", + "builtins.member_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.member_descriptor.__ge__" => "Return self>=value.", + "builtins.member_descriptor.__get__" => "Return an attribute of instance, which is of type owner.", + "builtins.member_descriptor.__getattribute__" => "Return getattr(self, name).", + "builtins.member_descriptor.__getstate__" => "Helper for pickle.", + "builtins.member_descriptor.__gt__" => "Return self>value.", + "builtins.member_descriptor.__hash__" => "Return hash(self).", + "builtins.member_descriptor.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.member_descriptor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.member_descriptor.__le__" => "Return self<=value.", + "builtins.member_descriptor.__lt__" => "Return self "Return self!=value.", + "builtins.member_descriptor.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.member_descriptor.__reduce_ex__" => "Helper for pickle.", + "builtins.member_descriptor.__repr__" => "Return repr(self).", + "builtins.member_descriptor.__set__" => "Set an attribute of instance to value.", + "builtins.member_descriptor.__setattr__" => "Implement setattr(self, name, value).", + "builtins.member_descriptor.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.member_descriptor.__str__" => "Return str(self).", + "builtins.member_descriptor.__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).", "builtins.memory_iterator.__delattr__" => "Implement delattr(self, name).", "builtins.memory_iterator.__eq__" => "Return self==value.", "builtins.memory_iterator.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", @@ -6581,7 +7001,97 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.memoryview.tobytes" => "Return the data in the buffer as a byte string.\n\nOrder can be {'C', 'F', 'A'}. When order is 'C' or 'F', the data of the\noriginal array is converted to C or Fortran order. For contiguous views,\n'A' returns an exact copy of the physical memory. In particular, in-memory\nFortran order is preserved. For non-contiguous views, the data is converted\nto C first. order=None is the same as order='C'.", "builtins.memoryview.tolist" => "Return the data in the buffer as a list of elements.", "builtins.memoryview.toreadonly" => "Return a readonly version of the memoryview.", + "builtins.method" => "Create a bound instance method object.", + "builtins.method-wrapper.__call__" => "Call self as a function.", + "builtins.method-wrapper.__delattr__" => "Implement delattr(self, name).", + "builtins.method-wrapper.__eq__" => "Return self==value.", + "builtins.method-wrapper.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.method-wrapper.__ge__" => "Return self>=value.", + "builtins.method-wrapper.__getattribute__" => "Return getattr(self, name).", + "builtins.method-wrapper.__getstate__" => "Helper for pickle.", + "builtins.method-wrapper.__gt__" => "Return self>value.", + "builtins.method-wrapper.__hash__" => "Return hash(self).", + "builtins.method-wrapper.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.method-wrapper.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.method-wrapper.__le__" => "Return self<=value.", + "builtins.method-wrapper.__lt__" => "Return self "Return self!=value.", + "builtins.method-wrapper.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.method-wrapper.__reduce_ex__" => "Helper for pickle.", + "builtins.method-wrapper.__repr__" => "Return repr(self).", + "builtins.method-wrapper.__setattr__" => "Implement setattr(self, name, value).", + "builtins.method-wrapper.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.method-wrapper.__str__" => "Return str(self).", + "builtins.method-wrapper.__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).", + "builtins.method.__call__" => "Call self as a function.", + "builtins.method.__delattr__" => "Implement delattr(self, name).", + "builtins.method.__eq__" => "Return self==value.", + "builtins.method.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.method.__func__" => "the function (or other callable) implementing a method", + "builtins.method.__ge__" => "Return self>=value.", + "builtins.method.__get__" => "Return an attribute of instance, which is of type owner.", + "builtins.method.__getattribute__" => "Return getattr(self, name).", + "builtins.method.__getstate__" => "Helper for pickle.", + "builtins.method.__gt__" => "Return self>value.", + "builtins.method.__hash__" => "Return hash(self).", + "builtins.method.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.method.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.method.__le__" => "Return self<=value.", + "builtins.method.__lt__" => "Return self "Return self!=value.", + "builtins.method.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.method.__reduce_ex__" => "Helper for pickle.", + "builtins.method.__repr__" => "Return repr(self).", + "builtins.method.__self__" => "the instance to which a method is bound", + "builtins.method.__setattr__" => "Implement setattr(self, name, value).", + "builtins.method.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.method.__str__" => "Return str(self).", + "builtins.method.__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).", + "builtins.method_descriptor.__call__" => "Call self as a function.", + "builtins.method_descriptor.__delattr__" => "Implement delattr(self, name).", + "builtins.method_descriptor.__eq__" => "Return self==value.", + "builtins.method_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.method_descriptor.__ge__" => "Return self>=value.", + "builtins.method_descriptor.__get__" => "Return an attribute of instance, which is of type owner.", + "builtins.method_descriptor.__getattribute__" => "Return getattr(self, name).", + "builtins.method_descriptor.__getstate__" => "Helper for pickle.", + "builtins.method_descriptor.__gt__" => "Return self>value.", + "builtins.method_descriptor.__hash__" => "Return hash(self).", + "builtins.method_descriptor.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.method_descriptor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.method_descriptor.__le__" => "Return self<=value.", + "builtins.method_descriptor.__lt__" => "Return self "Return self!=value.", + "builtins.method_descriptor.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.method_descriptor.__reduce_ex__" => "Helper for pickle.", + "builtins.method_descriptor.__repr__" => "Return repr(self).", + "builtins.method_descriptor.__setattr__" => "Implement setattr(self, name, value).", + "builtins.method_descriptor.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.method_descriptor.__str__" => "Return str(self).", + "builtins.method_descriptor.__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).", "builtins.min" => "min(iterable, *[, default=obj, key=func]) -> value\nmin(arg1, arg2, *args, *[, key=func]) -> value\n\nWith a single iterable argument, return its smallest item. The\ndefault keyword-only argument specifies an object to return if\nthe provided iterable is empty.\nWith two or more positional arguments, return the smallest argument.", + "builtins.module" => "Create a module object.\n\nThe name must be a string; the optional doc argument can have any type.", + "builtins.module.__delattr__" => "Implement delattr(self, name).", + "builtins.module.__eq__" => "Return self==value.", + "builtins.module.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.module.__ge__" => "Return self>=value.", + "builtins.module.__getattribute__" => "Return getattr(self, name).", + "builtins.module.__getstate__" => "Helper for pickle.", + "builtins.module.__gt__" => "Return self>value.", + "builtins.module.__hash__" => "Return hash(self).", + "builtins.module.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.module.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.module.__le__" => "Return self<=value.", + "builtins.module.__lt__" => "Return self "Return self!=value.", + "builtins.module.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.module.__reduce__" => "Helper for pickle.", + "builtins.module.__reduce_ex__" => "Helper for pickle.", + "builtins.module.__repr__" => "Return repr(self).", + "builtins.module.__setattr__" => "Implement setattr(self, name, value).", + "builtins.module.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.module.__str__" => "Return str(self).", + "builtins.module.__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).", "builtins.next" => "next(iterator[, default])\n\nReturn the next item from the iterator. If default is given and the iterator\nis exhausted, it is returned instead of raising StopIteration.", "builtins.object" => "The base class of the class hierarchy.\n\nWhen called, it accepts no arguments and returns a new featureless\ninstance that has no instance attributes and cannot be given any.", "builtins.object.__delattr__" => "Implement delattr(self, name).", @@ -6977,6 +7487,28 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.super.__str__" => "Return str(self).", "builtins.super.__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).", "builtins.super.__thisclass__" => "the class invoking super()", + "builtins.traceback" => "Create a new traceback object.", + "builtins.traceback.__delattr__" => "Implement delattr(self, name).", + "builtins.traceback.__eq__" => "Return self==value.", + "builtins.traceback.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.traceback.__ge__" => "Return self>=value.", + "builtins.traceback.__getattribute__" => "Return getattr(self, name).", + "builtins.traceback.__getstate__" => "Helper for pickle.", + "builtins.traceback.__gt__" => "Return self>value.", + "builtins.traceback.__hash__" => "Return hash(self).", + "builtins.traceback.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.traceback.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.traceback.__le__" => "Return self<=value.", + "builtins.traceback.__lt__" => "Return self "Return self!=value.", + "builtins.traceback.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.traceback.__reduce__" => "Helper for pickle.", + "builtins.traceback.__reduce_ex__" => "Helper for pickle.", + "builtins.traceback.__repr__" => "Return repr(self).", + "builtins.traceback.__setattr__" => "Implement setattr(self, name, value).", + "builtins.traceback.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.traceback.__str__" => "Return str(self).", + "builtins.traceback.__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).", "builtins.tuple" => "Built-in immutable sequence.\n\nIf no argument is given, the constructor returns an empty tuple.\nIf iterable is specified the tuple is initialized from iterable's items.\n\nIf the argument is a tuple, the return value is the same object.", "builtins.tuple.__add__" => "Return self+value.", "builtins.tuple.__class_getitem__" => "See PEP 585", @@ -7087,6 +7619,28 @@ pub static DB: phf::Map<&'static str, &'static str> = phf::phf_map! { "builtins.type.__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).", "builtins.type.mro" => "Return a type's method resolution order.", "builtins.vars" => "vars([object]) -> dictionary\n\nWithout arguments, equivalent to locals().\nWith an argument, equivalent to object.__dict__.", + "builtins.wrapper_descriptor.__call__" => "Call self as a function.", + "builtins.wrapper_descriptor.__delattr__" => "Implement delattr(self, name).", + "builtins.wrapper_descriptor.__eq__" => "Return self==value.", + "builtins.wrapper_descriptor.__format__" => "Default object formatter.\n\nReturn str(self) if format_spec is empty. Raise TypeError otherwise.", + "builtins.wrapper_descriptor.__ge__" => "Return self>=value.", + "builtins.wrapper_descriptor.__get__" => "Return an attribute of instance, which is of type owner.", + "builtins.wrapper_descriptor.__getattribute__" => "Return getattr(self, name).", + "builtins.wrapper_descriptor.__getstate__" => "Helper for pickle.", + "builtins.wrapper_descriptor.__gt__" => "Return self>value.", + "builtins.wrapper_descriptor.__hash__" => "Return hash(self).", + "builtins.wrapper_descriptor.__init__" => "Initialize self. See help(type(self)) for accurate signature.", + "builtins.wrapper_descriptor.__init_subclass__" => "This method is called when a class is subclassed.\n\nThe default implementation does nothing. It may be\noverridden to extend subclasses.", + "builtins.wrapper_descriptor.__le__" => "Return self<=value.", + "builtins.wrapper_descriptor.__lt__" => "Return self "Return self!=value.", + "builtins.wrapper_descriptor.__new__" => "Create and return a new object. See help(type) for accurate signature.", + "builtins.wrapper_descriptor.__reduce_ex__" => "Helper for pickle.", + "builtins.wrapper_descriptor.__repr__" => "Return repr(self).", + "builtins.wrapper_descriptor.__setattr__" => "Implement setattr(self, name, value).", + "builtins.wrapper_descriptor.__sizeof__" => "Size of object in memory, in bytes.", + "builtins.wrapper_descriptor.__str__" => "Return str(self).", + "builtins.wrapper_descriptor.__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).", "builtins.zip" => "The zip object yields n-length tuples, where n is the number of iterables\npassed as positional arguments to zip(). The i-th element in every tuple\ncomes from the i-th iterable argument to zip(). This continues until the\nshortest argument is exhausted.\n\nIf strict is true and one of the arguments is exhausted before the others,\nraise a ValueError.\n\n >>> list(zip('abcdefg', range(3), range(4)))\n [('a', 0, 0), ('b', 1, 1), ('c', 2, 2)]", "builtins.zip.__delattr__" => "Implement delattr(self, name).", "builtins.zip.__eq__" => "Return self==value.",