From 5324bd02f2fbac4ca0aedf9a7a44bb899a1cdb3e Mon Sep 17 00:00:00 2001 From: Shantanu Date: Thu, 20 Feb 2020 22:16:52 -0800 Subject: [PATCH] typeshed: run stubtest in CI (#3727) * README.md: refactor "Running the tests" This organises the section a little better. Previously some tests were unmentioned; it read as if mypy_test and pytype_test were the only tests. The section is now organised by test, making it easy to keep track of the requirements and details of each. This also makes it easier to add documentation for stubtest. Also mention turning on Travis CI on your fork, since that is very useful. * README.md: document stubtest_test.py * stubtest_test: add it * travis: add stubtest_test to CI * stubtest_test: add whitelists --- .travis.yml | 16 + README.md | 109 ++- tests/stubtest_test.py | 64 ++ tests/stubtest_whitelists/py35.txt | 106 +++ tests/stubtest_whitelists/py36.txt | 113 +++ tests/stubtest_whitelists/py37.txt | 147 ++++ tests/stubtest_whitelists/py38.txt | 302 ++++++++ tests/stubtest_whitelists/py3_common.txt | 942 +++++++++++++++++++++++ 8 files changed, 1765 insertions(+), 34 deletions(-) create mode 100755 tests/stubtest_test.py create mode 100644 tests/stubtest_whitelists/py35.txt create mode 100644 tests/stubtest_whitelists/py36.txt create mode 100644 tests/stubtest_whitelists/py37.txt create mode 100644 tests/stubtest_whitelists/py38.txt create mode 100644 tests/stubtest_whitelists/py3_common.txt diff --git a/.travis.yml b/.travis.yml index 3c595d768..3a24eb683 100644 --- a/.travis.yml +++ b/.travis.yml @@ -29,3 +29,19 @@ jobs: - name: "flake8" install: pip install -r requirements-tests-py3.txt script: flake8 + - name: "stubtest py38" + python: 3.8 + install: pip install -U git+git://github.com/python/mypy@a07dbd00 + script: ./tests/stubtest_test.py + - name: "stubtest py37" + python: 3.7 + install: pip install -U git+git://github.com/python/mypy@a07dbd00 + script: ./tests/stubtest_test.py + - name: "stubtest py36" + python: 3.6 + install: pip install -U git+git://github.com/python/mypy@a07dbd00 + script: ./tests/stubtest_test.py + - name: "stubtest py35" + python: 3.5 + install: pip install -U git+git://github.com/python/mypy@a07dbd00 + script: ./tests/stubtest_test.py diff --git a/README.md b/README.md index 9535cac06..180fecc97 100644 --- a/README.md +++ b/README.md @@ -86,24 +86,22 @@ requests. If you have questions related to contributing, drop by the [typing Git ## Running the tests The tests are automatically run by Travis CI on every PR and push to -the repo. There are several sets of tests: `tests/mypy_test.py` -runs tests against [mypy](https://github.com/python/mypy/), while -`tests/pytype_test.py` runs tests against +the repo. Note that it can be useful to enable Travis CI on your own fork of +typeshed. + +There are several tests: +- `tests/mypy_test.py` +runs tests against [mypy](https://github.com/python/mypy/) +- `tests/pytype_test.py` runs tests against [pytype](https://github.com/google/pytype/). +- `tests/mypy_selftest.py` runs mypy's test suite using this version of +typeshed. +- `tests/check_consistent.py` checks certain files in typeshed remain +consistent with each other. +- `tests/stubtest_test.py` checks stubs against the objects at runtime. +- `flake8` enforces a style guide. -Both sets of tests are shallow -- they verify that all stubs can be -imported but they don't check whether stubs match their implementation -(in the Python standard library or a third-party package). Also note -that each set of tests has a blacklist of modules that are not tested -at all. The blacklists also live in the tests directory. - -In addition, you can run `tests/mypy_selftest.py` to run mypy's own -test suite using the typeshed code in your repo. This will sometimes -catch issues with incorrectly typed stubs, but is much slower than the -other tests. - -To manually run the mypy tests, you need to have Python 3.5 or higher; -Python 3.6.1 or higher is recommended. +### Setup Run: ``` @@ -112,31 +110,74 @@ $ source .venv3/bin/activate (.venv3)$ pip3 install -r requirements-tests-py3.txt ``` This will install mypy (you need the latest master branch from GitHub), -typed-ast, flake8, and pytype. You can then run mypy, flake8, and pytype tests -by invoking: -``` -(.venv3)$ python3 tests/mypy_test.py -... -(.venv3)$ python3 tests/mypy_selftest.py -... -(.venv3)$ flake8 -... -(.venv3)$ python3 tests/pytype_test.py -... -``` -Note that flake8 only works with Python 3.6 or higher, and that to run the -pytype tests, you will need Python 2.7 and Python 3.6 interpreters. Pytype will -find these automatically if they're in `PATH`, but otherwise you must point to -them with the `--python27-exe` and `--python36-exe` arguments, respectively. +typed-ast, flake8 (and plugins), pytype, black and isort. -For mypy, if you are in the typeshed repo that is submodule of the +### mypy_test.py + +This test requires Python 3.5 or higher; Python 3.6.1 or higher is recommended. +Run using:`(.venv3)$ python3 tests/mypy_test.py` + +This test is shallow — it verifies that all stubs can be +imported but doesn't check whether stubs match their implementation +(in the Python standard library or a third-party package). It has a blacklist of +modules that are not tested at all, which also lives in the tests directory. + +If you are in the typeshed repo that is submodule of the mypy repo (so `..` refers to the mypy repo), there's a shortcut to run the mypy tests that avoids installing mypy: ```bash $ PYTHONPATH=../.. python3 tests/mypy_test.py ``` -You can mypy tests to a single version by passing `-p2` or `-p3.5` e.g. +You can restrict mypy tests to a single version by passing `-p2` or `-p3.5`: ```bash $ PYTHONPATH=../.. python3 tests/mypy_test.py -p3.5 running mypy --python-version 3.5 --strict-optional # with 342 files ``` + +### pytype_test.py + +This test requires Python 2.7 and Python 3.6. Pytype will +find these automatically if they're in `PATH`, but otherwise you must point to +them with the `--python27-exe` and `--python36-exe` arguments, respectively. +Run using: `(.venv3)$ python3 tests/pytype_test.py` + +This test works similarly to `mypy_test.py`, except it uses `pytype`. + +### mypy_selftest.py + +This test requires Python 3.5 or higher; Python 3.6.1 or higher is recommended. +Run using: `(.venv3)$ python3 tests/mypy_selftest.py` + +This test runs mypy's own test suite using the typeshed code in your repo. This +will sometimes catch issues with incorrectly typed stubs, but is much slower +than the other tests. + +### check_consistent.py + +Run using: `python3 tests/check_consistent.py` + +### stubtest_test.py + +This test requires Python 3.5 or higher. +Run using `(.venv3)$ python3 tests/stubtest_test.py` + +This test compares the stdlib stubs against the objects at runtime. Because of +this, the output depends on which version of Python it is run with. +If you need a specific version of Python to repro a CI failure, +[pyenv](https://github.com/pyenv/pyenv) can help (as can enabling Travis CI on +your fork). + +Due to its dynamic nature, you may run into false positives. In this case, you +can add to the whitelists for each affected Python version in +`tests/stubtest_whitelists`. Please file issues for stubtest false positives +at [mypy](https://github.com/python/mypy/issues). + +To run stubtest against third party stubs, it's easiest to use stubtest +directly. stubtest can also help you find things missing from the stubs. + + +### flake8 + +flake8 requires Python 3.6 or higher. Run using: `(.venv3)$ flake8` + +Note typeshed uses the `flake8-pyi` and `flake8-bugbear` plugins. diff --git a/tests/stubtest_test.py b/tests/stubtest_test.py new file mode 100755 index 000000000..4937321b0 --- /dev/null +++ b/tests/stubtest_test.py @@ -0,0 +1,64 @@ +#!/usr/bin/env python3 +"""Test typeshed using stubtest + +stubtest is a script in the mypy project that compares stubs to the actual objects at runtime. +Note that therefore the output of stubtest depends on which Python version it is run with. +In typeshed CI, we run stubtest with each Python minor version from 3.5 through 3.8 inclusive. + +We pin the version of mypy / stubtest we use in .travis.yml so changes to those don't break +typeshed CI. + +""" + +from pathlib import Path +import subprocess +import sys + + +def run_stubtest(typeshed_dir: Path) -> int: + whitelist_dir = typeshed_dir / "tests" / "stubtest_whitelists" + version_whitelist = "py{}{}.txt".format(sys.version_info.major, sys.version_info.minor) + + cmd = [ + sys.executable, + "-m", + "mypy.stubtest", + # Use --ignore-missing-stub, because if someone makes a correct addition, they'll need to + # also make a whitelist change and if someone makes an incorrect addition, they'll run into + # false negatives. + "--ignore-missing-stub", + "--check-typeshed", + "--custom-typeshed-dir", + str(typeshed_dir), + "--whitelist", + str(whitelist_dir / "py3_common.txt"), + "--whitelist", + str(whitelist_dir / version_whitelist), + ] + if sys.version_info < (3, 8): + # As discussed in https://github.com/python/typeshed/issues/3693, we only aim for + # positional-only arg accuracy for the latest Python version. + cmd += ["--ignore-positional-only"] + try: + print(" ".join(cmd), file=sys.stderr) + subprocess.run(cmd, check=True) + except subprocess.CalledProcessError as e: + print( + "\nNB: stubtest output depends on the Python version it is run with. See README.md " + "for more details.\n" + "NB: We only check positional-only arg accuracy for Python 3.8.\n" + "If stubtest is complaining about 'unused whitelist entry' after your fix, please " + "remove the entry from the whitelist file. Note you may have to do this for other " + "version-specific whitelists as well. Thanks for helping burn the backlog of errors!\n" + "\nCommand run was: {}\n".format(" ".join(cmd)), + file=sys.stderr, + ) + print("stubtest failed", file=sys.stderr) + return e.returncode + else: + print("stubtest succeeded", file=sys.stderr) + return 0 + + +if __name__ == "__main__": + sys.exit(run_stubtest(typeshed_dir=Path("."))) diff --git a/tests/stubtest_whitelists/py35.txt b/tests/stubtest_whitelists/py35.txt new file mode 100644 index 000000000..a0d6dbbcd --- /dev/null +++ b/tests/stubtest_whitelists/py35.txt @@ -0,0 +1,106 @@ +asyncio.Future._callbacks +asyncio.Future._exception +asyncio.Future._loop +asyncio.Future._tb_logger +asyncio.Task.__init__ +asyncio.constants.DEBUG_STACK_DEPTH +asyncio.constants.SENDFILE_FALLBACK_READBUFFER_SIZE +asyncio.constants.SSL_HANDSHAKE_TIMEOUT +asyncio.exceptions +asyncio.futures.Future._callbacks +asyncio.futures.Future._exception +asyncio.futures.Future._loop +asyncio.futures.Future._tb_logger +asyncio.futures._TracebackLogger.__init__ +asyncio.protocols.BufferedProtocol +asyncio.runners +asyncio.tasks.Task.__init__ +bdb.GENERATOR_AND_COROUTINE_FLAGS +builtins.str.maketrans +cgi.escape +cmath.log +codecs.StreamRecoder.seek +collections.Reversible +collections.UserString.maketrans +ctypes.CDLL.__init__ +decimal.Decimal.as_integer_ratio +gettext.NullTranslations.npgettext +gettext.NullTranslations.pgettext +gettext.dnpgettext +gettext.dpgettext +gettext.npgettext +gettext.pgettext +importlib.metadata +importlib.resources +io.BufferedRandom.read1 +io.BufferedReader.read1 +io.StringIO.readline +ipaddress._BaseNetwork.__init__ +macpath.basename +macpath.commonpath +macpath.commonprefix +macpath.dirname +macpath.getatime +macpath.getctime +macpath.getmtime +macpath.getsize +macpath.isabs +macpath.isdir +macpath.islink +macpath.ismount +macpath.join +macpath.normpath +macpath.realpath +macpath.relpath +macpath.samefile +macpath.samestat +macpath.split +macpath.splitdrive +macpath.splitext +mmap.ACCESS_DEFAULT +modulefinder.ModuleFinder.scan_opcodes +multiprocessing.context.BaseContext.reducer +multiprocessing.shared_memory +os.DirEntry +os.utime +pyexpat.XMLParserType.ExternalEntityParserCreate +smtpd.SMTPChannel.__init__ +smtpd.SMTPServer.__init__ +socket.NETLINK_CRYPTO +sre_compile.dis +sre_parse.GLOBAL_FLAGS +sre_parse.Tokenizer.pos +sre_parse.Verbose +subprocess.check_output +tracemalloc.Filter.__init__ +typing.AbstractSet.isdisjoint +typing.Coroutine.cr_await +typing.Coroutine.cr_code +typing.Coroutine.cr_frame +typing.Coroutine.cr_running +typing.Generator.gi_code +typing.Generator.gi_frame +typing.Generator.gi_running +typing.Generator.gi_yieldfrom +typing.Mapping.get +typing.MutableMapping.pop +typing.MutableMapping.setdefault +typing.MutableSequence.append +typing.MutableSequence.extend +typing.MutableSequence.insert +typing.MutableSequence.remove +typing.MutableSet.add +typing.MutableSet.discard +typing.MutableSet.remove +typing.Protocol +typing.Sequence.count +typing.Sequence.index +typing.Type +typing.runtime_checkable +unittest.async_case +uuid.UUID.int +uuid.getnode +xml.etree.cElementTree.XMLPullParser +xml.parsers.expat.XMLParserType.ExternalEntityParserCreate +zipfile.ZipFile.open +zlib.compress diff --git a/tests/stubtest_whitelists/py36.txt b/tests/stubtest_whitelists/py36.txt new file mode 100644 index 000000000..c80f09a9e --- /dev/null +++ b/tests/stubtest_whitelists/py36.txt @@ -0,0 +1,113 @@ +asyncio.Future.__init__ +asyncio.Task._wakeup +asyncio.constants.SENDFILE_FALLBACK_READBUFFER_SIZE +asyncio.constants.SSL_HANDSHAKE_TIMEOUT +asyncio.exceptions +asyncio.futures.Future.__init__ +asyncio.futures._TracebackLogger.__init__ +asyncio.protocols.BufferedProtocol +asyncio.runners +asyncio.tasks.Task._wakeup +builtins.str.maketrans +cgi.escape +cmath.log +codecs.StreamRecoder.seek +collections.AsyncGenerator.ag_await +collections.AsyncGenerator.ag_code +collections.AsyncGenerator.ag_frame +collections.AsyncGenerator.ag_running +collections.UserString.maketrans +collections.abc.AsyncGenerator.ag_await +collections.abc.AsyncGenerator.ag_code +collections.abc.AsyncGenerator.ag_frame +collections.abc.AsyncGenerator.ag_running +copy.PyStringMap +ctypes.CDLL.__init__ +email.message.MIMEPart.as_string +email.mime.message.MIMEMessage.__init__ +email.mime.text.MIMEText.__init__ +enum.Enum._generate_next_value_ +gettext.NullTranslations.npgettext +gettext.NullTranslations.pgettext +gettext.dnpgettext +gettext.dpgettext +gettext.npgettext +gettext.pgettext +importlib.metadata +importlib.resources +io.BufferedRandom.read1 +io.BufferedReader.read1 +io.StringIO.readline +ipaddress._BaseNetwork.__init__ +json.dump +json.dumps +json.load +json.loads +logging.handlers.MemoryHandler.__init__ +macpath.basename +macpath.commonpath +macpath.commonprefix +macpath.dirname +macpath.getatime +macpath.getctime +macpath.getmtime +macpath.getsize +macpath.isabs +macpath.isdir +macpath.islink +macpath.ismount +macpath.join +macpath.normpath +macpath.realpath +macpath.relpath +macpath.samefile +macpath.samestat +macpath.split +macpath.splitdrive +macpath.splitext +mmap.ACCESS_DEFAULT +multiprocessing.shared_memory +os.utime +pyexpat.XMLParserType.ExternalEntityParserCreate +secrets.SystemRandom.getstate +smtplib.SMTP.sendmail +sre_compile.dis +ssl.SSLContext.wrap_bio +ssl.SSLContext.wrap_socket +tkinter.Menu.tk_bindForTraversal +tkinter.Misc.tk_menuBar +typing.AbstractSet.isdisjoint +typing.AsyncGenerator.ag_await +typing.AsyncGenerator.ag_code +typing.AsyncGenerator.ag_frame +typing.AsyncGenerator.ag_running +typing.Coroutine.cr_await +typing.Coroutine.cr_code +typing.Coroutine.cr_frame +typing.Coroutine.cr_running +typing.Generator.gi_code +typing.Generator.gi_frame +typing.Generator.gi_running +typing.Generator.gi_yieldfrom +typing.Mapping.get +typing.MutableMapping.pop +typing.MutableMapping.setdefault +typing.MutableSequence.append +typing.MutableSequence.extend +typing.MutableSequence.insert +typing.MutableSequence.remove +typing.MutableSet.add +typing.MutableSet.discard +typing.MutableSet.remove +typing.Protocol +typing.Sequence.count +typing.Sequence.index +typing.Type +typing.runtime_checkable +unittest.async_case +urllib.parse.parse_qs +urllib.parse.parse_qsl +uuid.UUID.int +uuid.getnode +webbrowser.Opera.raise_opts +xml.parsers.expat.XMLParserType.ExternalEntityParserCreate diff --git a/tests/stubtest_whitelists/py37.txt b/tests/stubtest_whitelists/py37.txt new file mode 100644 index 000000000..249a94a0e --- /dev/null +++ b/tests/stubtest_whitelists/py37.txt @@ -0,0 +1,147 @@ +_bisect.bisect +_bisect.insort +_tracemalloc._get_object_traceback +_tracemalloc.start +asyncio.AbstractEventLoop.create_unix_server +asyncio.AbstractEventLoop.sock_sendfile +asyncio.Future.__init__ +asyncio.Future._callbacks +asyncio.Future._schedule_callbacks +asyncio.Handle.__init__ +asyncio.TimerHandle.__init__ +asyncio.events.AbstractEventLoop.create_unix_server +asyncio.events.AbstractEventLoop.sock_sendfile +asyncio.events.Handle.__init__ +asyncio.events.TimerHandle.__init__ +asyncio.exceptions +asyncio.futures.Future.__init__ +asyncio.futures.Future._callbacks +asyncio.futures.Future._schedule_callbacks +asyncio.proactor_events.BaseProactorEventLoop.create_unix_server +asyncio.selector_events.BaseSelectorEventLoop.create_unix_server +builtins.dict.get +builtins.reversed +builtins.str.maketrans +cgi.escape +cmath.log +collections.AsyncGenerator.ag_await +collections.AsyncGenerator.ag_code +collections.AsyncGenerator.ag_frame +collections.AsyncGenerator.ag_running +collections.UserString.maketrans +collections.abc.AsyncGenerator.ag_await +collections.abc.AsyncGenerator.ag_code +collections.abc.AsyncGenerator.ag_frame +collections.abc.AsyncGenerator.ag_running +concurrent.futures.BrokenThreadPool +contextvars.Context.__init__ +contextvars.Context.get +copy.PyStringMap +ctypes.CDLL.__init__ +dataclasses.dataclass +dataclasses.field +dataclasses.make_dataclass +email.message.MIMEPart.as_string +email.mime.message.MIMEMessage.__init__ +email.mime.text.MIMEText.__init__ +enum.Enum._generate_next_value_ +gc.collect +gettext.NullTranslations.npgettext +gettext.NullTranslations.pgettext +gettext.dnpgettext +gettext.dpgettext +gettext.npgettext +gettext.pgettext +http.client.HTTPSConnection.__init__ +http.server.SimpleHTTPRequestHandler.__init__ +importlib.metadata +ipaddress._BaseNetwork.__init__ +json.dump +json.dumps +json.load +json.loads +logging.handlers.MemoryHandler.__init__ +macpath.basename +macpath.commonpath +macpath.commonprefix +macpath.dirname +macpath.getatime +macpath.getctime +macpath.getmtime +macpath.getsize +macpath.isabs +macpath.isdir +macpath.islink +macpath.ismount +macpath.join +macpath.normpath +macpath.realpath +macpath.relpath +macpath.samefile +macpath.samestat +macpath.split +macpath.splitdrive +macpath.splitext +marshal.loads +multiprocessing.shared_memory +os.utime +pyclbr.Class.__init__ +pyclbr.Function.__init__ +pyexpat.XMLParserType.ExternalEntityParserCreate +queue.SimpleQueue.__init__ +secrets.SystemRandom.getstate +smtplib.SMTP.sendmail +sre_constants.RANGE_IGNORE +ssl.SSLContext.wrap_bio +ssl.SSLContext.wrap_socket +struct.calcsize +struct.iter_unpack +struct.unpack +struct.unpack_from +time.CLOCK_PROF +time.CLOCK_UPTIME +tkinter.Menu.tk_bindForTraversal +tkinter.Misc.tk_menuBar +tracemalloc.Traceback.format +types.ClassMethodDescriptorType.__get__ +types.MethodDescriptorType.__get__ +types.WrapperDescriptorType.__get__ +typing.AbstractSet +typing.AsyncContextManager +typing.AsyncGenerator +typing.AsyncIterable +typing.AsyncIterator +typing.Awaitable +typing.ByteString +typing.Collection +typing.Container +typing.ContextManager +typing.Coroutine +typing.Generator +typing.GenericMeta +typing.Hashable +typing.ItemsView +typing.Iterable +typing.Iterator +typing.KeysView +typing.Mapping +typing.MappingView +typing.MutableMapping +typing.MutableSequence +typing.MutableSet +typing.Optional +typing.Protocol +typing.Reversible +typing.Sequence +typing.Sized +typing.Union +typing.ValuesView +typing.runtime_checkable +unittest.async_case +urllib.parse.parse_qs +urllib.parse.parse_qsl +uuid.UUID.int +uuid.UUID.is_safe +webbrowser.Opera.raise_opts +xml.parsers.expat.XMLParserType.ExternalEntityParserCreate +zipfile.ZipExtFile.__init__ diff --git a/tests/stubtest_whitelists/py38.txt b/tests/stubtest_whitelists/py38.txt new file mode 100644 index 000000000..ec63cb14e --- /dev/null +++ b/tests/stubtest_whitelists/py38.txt @@ -0,0 +1,302 @@ +_bisect.bisect +_bisect.insort +_imp.create_builtin +_imp.exec_builtin +_imp.exec_dynamic +_imp.get_frozen_object +_imp.init_frozen +_imp.is_builtin +_imp.is_frozen +_imp.is_frozen_package +_thread.ExceptHookArgs +_thread._ExceptHookArgs +_tracemalloc._get_object_traceback +_tracemalloc.start +_weakref.getweakrefcount +asyncio.AbstractEventLoop.create_unix_server +asyncio.AbstractEventLoop.sock_sendfile +asyncio.Future.__init__ +asyncio.Future._callbacks +asyncio.Future._schedule_callbacks +asyncio.Future.remove_done_callback +asyncio.Future.set_exception +asyncio.Future.set_result +asyncio.Handle.__init__ +asyncio.Task.remove_done_callback +asyncio.Task.set_exception +asyncio.Task.set_name +asyncio.Task.set_result +asyncio.TimerHandle.__init__ +asyncio._set_running_loop +asyncio.events.AbstractEventLoop.create_unix_server +asyncio.events.AbstractEventLoop.sock_sendfile +asyncio.events.Handle.__init__ +asyncio.events.TimerHandle.__init__ +asyncio.events._set_running_loop +asyncio.futures.Future.__init__ +asyncio.futures.Future._callbacks +asyncio.futures.Future._schedule_callbacks +asyncio.futures.Future.remove_done_callback +asyncio.futures.Future.set_exception +asyncio.futures.Future.set_result +asyncio.proactor_events.BaseProactorEventLoop.create_unix_server +asyncio.proactor_events._ProactorBasePipeTransport.__del__ +asyncio.selector_events.BaseSelectorEventLoop.create_unix_server +asyncio.tasks.Task.remove_done_callback +asyncio.tasks.Task.set_exception +asyncio.tasks.Task.set_name +asyncio.tasks.Task.set_result +bdb.Bdb.runcall +binascii.a2b_hex +binascii.b2a_base64 +binascii.b2a_hqx +binascii.b2a_uu +binascii.crc32 +binascii.crc_hqx +binascii.rlecode_hqx +binascii.rledecode_hqx +builtins.bytearray.extend +builtins.bytearray.pop +builtins.compile +builtins.dict.get +builtins.reversed +bz2.BZ2Compressor.compress +bz2.BZ2File.read +bz2.BZ2File.read1 +bz2.BZ2File.readline +bz2.BZ2File.seek +cProfile.Profile.runcall +codecs.lookup +codecs.lookup_error +codecs.register +collections.AsyncGenerator.ag_await +collections.AsyncGenerator.ag_code +collections.AsyncGenerator.ag_frame +collections.AsyncGenerator.ag_running +collections.Container.__contains__ +collections.ItemsView.__reversed__ +collections.KeysView.__reversed__ +collections.OrderedDict.fromkeys +collections.OrderedDict.setdefault +collections.ValuesView.__reversed__ +collections.abc.AsyncGenerator.ag_await +collections.abc.AsyncGenerator.ag_code +collections.abc.AsyncGenerator.ag_frame +collections.abc.AsyncGenerator.ag_running +collections.abc.Container.__contains__ +collections.abc.ItemsView.__reversed__ +collections.abc.KeysView.__reversed__ +collections.abc.ValuesView.__reversed__ +concurrent.futures.BrokenThreadPool +concurrent.futures.Executor.submit +concurrent.futures.ProcessPoolExecutor.submit +concurrent.futures.ThreadPoolExecutor.submit +concurrent.futures._base.Executor.submit +concurrent.futures.process.ProcessPoolExecutor.submit +concurrent.futures.thread.ThreadPoolExecutor.submit +contextlib.AbstractContextManager.__exit__ +contextlib.AsyncExitStack.callback +contextlib.AsyncExitStack.push_async_callback +contextlib.ExitStack.callback +contextvars.Context.__init__ +contextvars.Context.get +contextvars.ContextVar.reset +contextvars.ContextVar.set +copy.PyStringMap +curses.panel.new_panel +curses.wrapper +dataclasses.dataclass +dataclasses.field +dataclasses.make_dataclass +dataclasses.replace +datetime.date.fromtimestamp +decimal.Decimal.from_float +decimal.setcontext +dis.stack_effect +email.message.MIMEPart.as_string +email.mime.message.MIMEMessage.__init__ +email.mime.text.MIMEText.__init__ +enum.Enum._generate_next_value_ +fcntl.fcntl +fcntl.flock +fcntl.ioctl +fcntl.lockf +functools.partialmethod.__get__ +gc.collect +gc.is_tracked +gc.set_debug +gettext.install +gettext.translation +hmac.compare_digest +http.client.HTTPSConnection.__init__ +http.cookiejar.DefaultCookiePolicy.__init__ +http.server.SimpleHTTPRequestHandler.__init__ +imp.get_frozen_object +imp.init_frozen +imp.is_builtin +imp.is_frozen +imp.is_frozen_package +importlib.metadata.EntryPointBase +inspect.getcallargs +inspect.isasyncgenfunction +inspect.iscoroutinefunction +inspect.isgeneratorfunction +io.IncrementalNewlineDecoder.setstate +ipaddress.IPv4Interface.hostmask +ipaddress.IPv6Interface.hostmask +ipaddress._BaseNetwork.broadcast_address +ipaddress._BaseNetwork.hostmask +itertools.tee +json.dump +json.dumps +json.load +json.loads +logging.handlers.MemoryHandler.__init__ +lzma.LZMACompressor.compress +lzma.is_check_supported +macpath +marshal.dump +marshal.dumps +marshal.load +marshal.loads +mmap.MADV_AUTOSYNC +mmap.MADV_CORE +mmap.MADV_NOCORE +mmap.MADV_NOSYNC +mmap.MADV_PROTECT +mmap.MADV_SOFT_OFFLINE +modulefinder.ModuleFinder.__init__ +multiprocessing.pool.CLOSE +multiprocessing.pool.RUN +multiprocessing.pool.TERMINATE +multiprocessing.spawn._main +opcode.stack_effect +os.MFD_HUGE_32MB +os.MFD_HUGE_512MB +os.pipe2 +os.posix_fadvise +os.posix_fallocate +os.sched_getaffinity +os.sched_getparam +os.sched_getscheduler +os.sched_rr_get_interval +os.sched_setaffinity +os.sched_setparam +os.sched_setscheduler +os.setresgid +os.setresuid +os.waitid +pickle.Pickler.dump +pickle.Pickler.reducer_override +pickle.Pickler.reducer_override-redefinition +platform.DEV_NULL +profile.Profile.runcall +pwd.getpwuid +py_compile.compile +pyclbr.Class.__init__ +pyclbr.Function.__init__ +queue.SimpleQueue.__init__ +random.Random.getrandbits +random.getrandbits +re.Match.end +re.Match.span +re.Match.start +resource.getrlimit +resource.getrusage +resource.setrlimit +secrets.SystemRandom.getstate +secrets.compare_digest +select.epoll.__exit__ +select.epoll.fromfd +select.epoll.poll +select.select +signal.sigtimedwait +signal.sigwaitinfo +smtplib.SMTP.sendmail +sre_constants.RANGE_IGNORE +sre_parse.Tokenizer.getuntil +ssl.MemoryBIO.read +ssl.MemoryBIO.write +ssl.RAND_bytes +ssl.RAND_pseudo_bytes +ssl.SSLContext.wrap_bio +ssl.SSLContext.wrap_socket +statistics.NormalDist.samples +string.Formatter.format +string.Template.safe_substitute +string.Template.substitute +struct.Struct.iter_unpack +struct.Struct.unpack +struct.calcsize +struct.iter_unpack +struct.unpack +struct.unpack_from +sys.UnraisableHookArgs +sys._getframe +sys.call_tracing +sys.exit +sys.getrefcount +sys.intern +sys.setcheckinterval +sys.setdlopenflags +sys.setrecursionlimit +sys.setswitchinterval +tempfile.NamedTemporaryFile +tempfile.SpooledTemporaryFile.__init__ +tempfile.TemporaryFile +threading.ExceptHookArgs +time.CLOCK_PROF +time.CLOCK_UPTIME +tkinter.Menu.tk_bindForTraversal +tkinter.Misc.tk_menuBar +trace.Trace.runfunc +tracemalloc.Traceback.format +tracemalloc.start +types.ClassMethodDescriptorType.__get__ +types.CodeType.replace +types.MethodDescriptorType.__get__ +types.WrapperDescriptorType.__get__ +typing.AbstractSet +typing.AsyncContextManager +typing.AsyncGenerator +typing.AsyncIterable +typing.AsyncIterator +typing.Awaitable +typing.ByteString +typing.Collection +typing.Container +typing.ContextManager +typing.Coroutine +typing.Generator +typing.GenericMeta +typing.Hashable +typing.ItemsView +typing.Iterable +typing.Iterator +typing.KeysView +typing.Mapping +typing.MappingView +typing.MutableMapping +typing.MutableSequence +typing.MutableSet +typing.Optional +typing.Reversible +typing.Sequence +typing.Sized +typing.Union +typing.ValuesView +unittest.TestCase.addCleanup +unittest.case.TestCase.addCleanup +unittest.doModuleCleanups +unittest.mock.MagicProxy.__call__ +unittest.mock._MockIter.__iter__ +weakref.WeakValueDictionary.__init__ +weakref.WeakValueDictionary.update +weakref.getweakrefcount +webbrowser.Opera.raise_opts +xml.etree.ElementTree.XMLParser.__init__ +xml.etree.cElementTree.XMLParser.__init__ +xml.sax.make_parser +zipfile.Path.open +zipfile.ZipExtFile.__init__ +zipfile.ZipExtFile.seek diff --git a/tests/stubtest_whitelists/py3_common.txt b/tests/stubtest_whitelists/py3_common.txt new file mode 100644 index 000000000..287d5bc0a --- /dev/null +++ b/tests/stubtest_whitelists/py3_common.txt @@ -0,0 +1,942 @@ +_csv.Dialect.__init__ +_dummy_threading +_importlib_modulespec +_operator.methodcaller +_posixsubprocess.cloexec_pipe +_subprocess +_types +_weakref.CallableProxyType.__getattr__ +_weakref.ProxyType.__getattr__ +_weakref.ReferenceType.__call__ +_winapi +abc.abstractclassmethod +abc.abstractmethod +abc.abstractstaticmethod +aifc.open +aifc.openfp +argparse.Namespace.__getattr__ +asyncio.AbstractEventLoop.connect_accepted_socket +asyncio.AbstractEventLoop.create_unix_connection +asyncio.BaseChildWatcher +asyncio.BaseEventLoop.subprocess_exec +asyncio.Condition.acquire +asyncio.Condition.locked +asyncio.Condition.release +asyncio.Future._copy_state +asyncio.Queue._consume_done_getters +asyncio.Queue._consume_done_putters +asyncio.Server +asyncio.StreamReaderProtocol.__init__ +asyncio.Task._step +asyncio.Task.get_stack +asyncio.Task.print_stack +asyncio.WriteTransport.set_write_buffer_limits +asyncio.base_events.BaseEventLoop.subprocess_exec +asyncio.create_subprocess_exec +asyncio.create_subprocess_shell +asyncio.events.AbstractEventLoop.connect_accepted_socket +asyncio.events.AbstractEventLoop.create_unix_connection +asyncio.futures.Future._copy_state +asyncio.futures.wrap_future +asyncio.locks.Condition.acquire +asyncio.locks.Condition.locked +asyncio.locks.Condition.release +asyncio.open_connection +asyncio.open_unix_connection +asyncio.proactor_events.BaseProactorEventLoop.create_unix_connection +asyncio.proactor_events.BaseProactorEventLoop.sock_recv +asyncio.queues.Queue._consume_done_getters +asyncio.queues.Queue._consume_done_putters +asyncio.selector_events.BaseSelectorEventLoop.create_unix_connection +asyncio.selector_events.BaseSelectorEventLoop.sock_recv +asyncio.sleep +asyncio.start_unix_server +asyncio.streams.StreamReaderProtocol.__init__ +asyncio.streams.open_connection +asyncio.streams.open_unix_connection +asyncio.streams.start_unix_server +asyncio.subprocess.create_subprocess_exec +asyncio.subprocess.create_subprocess_shell +asyncio.tasks.Task._step +asyncio.tasks.Task.get_stack +asyncio.tasks.Task.print_stack +asyncio.tasks.sleep +asyncio.transports.WriteTransport.set_write_buffer_limits +asyncio.transports._FlowControlMixin.set_write_buffer_limits +asyncio.unix_events._UnixSelectorEventLoop.create_unix_connection +asyncio.unix_events._UnixSelectorEventLoop.create_unix_server +asyncio.windows_events +asyncio.windows_utils +asyncio.wrap_future +asyncore.close_all +asyncore.dispatcher.__init__ +asyncore.dispatcher.add_channel +asyncore.dispatcher.bind +asyncore.dispatcher.create_socket +asyncore.dispatcher.del_channel +asyncore.dispatcher.listen +asyncore.dispatcher.set_socket +asyncore.dispatcher_with_send.__init__ +asyncore.file_dispatcher.__init__ +asyncore.file_wrapper.getsockopt +asyncore.loop +asyncore.poll +asyncore.poll2 +base64.b32decode +base64.b64decode +base64.b64encode +bdb.Bdb.__init__ +binascii.a2b_base64 +binascii.a2b_hqx +binascii.a2b_qp +binascii.a2b_uu +binascii.unhexlify +builtins.WindowsError +builtins.bytearray.__float__ +builtins.bytearray.__int__ +builtins.bytearray.append +builtins.bytearray.maketrans +builtins.bytearray.remove +builtins.bytes.__float__ +builtins.bytes.__int__ +builtins.bytes.maketrans +builtins.classmethod.__get__ +builtins.complex.__complex__ +builtins.complex.__pow__ +builtins.complex.__rpow__ +builtins.copyright +builtins.credits +builtins.ellipsis +builtins.exit +builtins.float.__pow__ +builtins.float.__rpow__ +builtins.function +builtins.help +builtins.int.__rpow__ +builtins.license +builtins.memoryview.__contains__ +builtins.memoryview.__iter__ +builtins.memoryview.cast +builtins.object.__init__ +builtins.property.__get__ +builtins.property.fdel +builtins.property.fget +builtins.property.fset +builtins.quit +builtins.reveal_locals +builtins.reveal_type +builtins.staticmethod.__get__ +bz2.BZ2File.readinto +bz2.BZ2File.readlines +bz2.BZ2File.write +bz2.BZ2File.writelines +cgi.FieldStorage.__init__ +cgi.parse +cgi.parse_header +codecs.BufferedIncrementalDecoder.decode +codecs.CodecInfo.decode +codecs.CodecInfo.encode +codecs.CodecInfo.incrementaldecoder +codecs.CodecInfo.incrementalencoder +codecs.CodecInfo.streamreader +codecs.CodecInfo.streamwriter +codecs.EncodedFile +codecs.IncrementalDecoder.decode +codecs.IncrementalEncoder.encode +codecs.StreamReader.__getattr__ +codecs.StreamReader.readline +codecs.StreamReader.readlines +codecs.StreamReaderWriter.__getattr__ +codecs.StreamReaderWriter.close +codecs.StreamReaderWriter.fileno +codecs.StreamReaderWriter.flush +codecs.StreamReaderWriter.isatty +codecs.StreamReaderWriter.readable +codecs.StreamReaderWriter.seekable +codecs.StreamReaderWriter.tell +codecs.StreamReaderWriter.truncate +codecs.StreamReaderWriter.writable +codecs.StreamRecoder.__getattr__ +codecs.StreamRecoder.close +codecs.StreamRecoder.fileno +codecs.StreamRecoder.flush +codecs.StreamRecoder.isatty +codecs.StreamRecoder.readable +codecs.StreamRecoder.seekable +codecs.StreamRecoder.tell +codecs.StreamRecoder.truncate +codecs.StreamRecoder.writable +codecs.StreamWriter.__getattr__ +codecs.StreamWriter.write +codecs.open +codecs.register_error +codecs.utf_16_be_decode +codecs.utf_16_be_encode +collections.Callable +collections.ChainMap.get +collections.ChainMap.maps +collections.ChainMap.new_child +collections.ChainMap.pop +collections.Coroutine.cr_await +collections.Coroutine.cr_code +collections.Coroutine.cr_frame +collections.Coroutine.cr_running +collections.Counter.fromkeys +collections.Generator.gi_code +collections.Generator.gi_frame +collections.Generator.gi_running +collections.Generator.gi_yieldfrom +collections.Mapping.get +collections.MutableMapping.pop +collections.MutableMapping.setdefault +collections.MutableSequence.append +collections.MutableSequence.extend +collections.MutableSequence.insert +collections.MutableSequence.remove +collections.MutableSet.add +collections.MutableSet.discard +collections.MutableSet.remove +collections.Sequence.count +collections.Sequence.index +collections.Set.isdisjoint +collections.abc.Callable +collections.abc.Coroutine.cr_await +collections.abc.Coroutine.cr_code +collections.abc.Coroutine.cr_frame +collections.abc.Coroutine.cr_running +collections.abc.Generator.gi_code +collections.abc.Generator.gi_frame +collections.abc.Generator.gi_running +collections.abc.Generator.gi_yieldfrom +collections.abc.Mapping.get +collections.abc.MutableMapping.pop +collections.abc.MutableMapping.setdefault +collections.abc.MutableSequence.append +collections.abc.MutableSequence.extend +collections.abc.MutableSequence.insert +collections.abc.MutableSequence.remove +collections.abc.MutableSet.add +collections.abc.MutableSet.discard +collections.abc.MutableSet.remove +collections.abc.Sequence.count +collections.abc.Sequence.index +collections.abc.Set.isdisjoint +collections.deque.__hash__ +concurrent.futures.BrokenProcessPool +concurrent.futures.CANCELLED +concurrent.futures.CANCELLED_AND_NOTIFIED +concurrent.futures.EXTRA_QUEUED_CALLS +concurrent.futures.Error +concurrent.futures.Executor.map +concurrent.futures.FINISHED +concurrent.futures.LOGGER +concurrent.futures.PENDING +concurrent.futures.ProcessPoolExecutor.map +concurrent.futures.RUNNING +concurrent.futures._base.Executor.map +concurrent.futures.process.ProcessPoolExecutor.map +configparser.LegacyInterpolation.before_get +configparser.SectionProxy.__getattr__ +configparser.SectionProxy.getboolean +configparser.SectionProxy.getfloat +configparser.SectionProxy.getint +contextlib.ContextManager +csv.Dialect.delimiter +csv.Dialect.doublequote +csv.Dialect.lineterminator +csv.Dialect.quoting +csv.Dialect.skipinitialspace +ctypes.Array.__iter__ +ctypes.CDLL._FuncPtr +ctypes.cast +ctypes.create_string_buffer +ctypes.create_unicode_buffer +ctypes.memmove +ctypes.memset +ctypes.pointer +ctypes.string_at +ctypes.wintypes +ctypes.wstring_at +curses.COLORS +curses.COLOR_PAIRS +curses.COLS +curses.LINES +curses.textpad.Textbox.__init__ +curses.textpad.Textbox.edit +dbm.error +dbm.ndbm +decimal.DecimalException.handle +difflib.Differ.__init__ +difflib.HtmlDiff.__init__ +difflib.SequenceMatcher.__init__ +difflib.ndiff +dis.dis +distutils.archive_util.make_archive +distutils.archive_util.make_tarball +distutils.command.bdist_msi +distutils.command.bdist_packager +distutils.core.Extension.__init__ +distutils.debug.DEBUG +distutils.extension.Extension.__init__ +distutils.sysconfig.set_python_build +distutils.text_file.TextFile.warn +distutils.version.Version._cmp +distutils.version.Version.parse +doctest.testmod +email.feedparser.BytesFeedParser.__init__ +email.feedparser.FeedParser.__init__ +email.generator.BytesGenerator.__init__ +email.generator.DecodedGenerator.__init__ +email.generator.Generator.__init__ +email.headerregistry.AddressHeader.parse +email.headerregistry.BaseHeader.init +email.headerregistry.BaseHeader.max_count +email.headerregistry.ContentTransferEncodingHeader.parse +email.headerregistry.DateHeader.parse +email.headerregistry.HeaderRegistry.__init__ +email.headerregistry.MIMEVersionHeader.parse +email.headerregistry.ParameterizedMIMEHeader.parse +email.headerregistry.UnstructuredHeader.parse +email.message.Message.get_payload +email.message.Message.set_param +email.parser.HeaderParser.__init__ +email.parser.Parser.__init__ +email.utils.localtime +email.utils.mktime_tz +email.utils.parseaddr +email.utils.parsedate +email.utils.parsedate_to_datetime +email.utils.parsedate_tz +encodings.utf_8.IncrementalDecoder._buffer_decode +encodings.utf_8.StreamReader.decode +encodings.utf_8.StreamWriter.encode +encodings.utf_8.encode +errno.EDEADLCK +fcntl.F_FULLFSYNC +fcntl.F_NOCACHE +gettext.GNUTranslations.lngettext +gettext.GNUTranslations.ngettext +gettext.NullTranslations.__init__ +gettext.NullTranslations.lngettext +gettext.NullTranslations.ngettext +gettext.dngettext +gettext.ldngettext +gettext.lngettext +gettext.ngettext +grp.getgrgid +grp.struct_group._asdict +grp.struct_group._make +grp.struct_group._replace +html.parser.HTMLParser.feed +http.HTTPStatus.description +http.HTTPStatus.phrase +http.client.HTTPResponse.read1 +http.client.HTTPResponse.readinto +http.client.HTTPResponse.readline +http.cookiejar.Cookie.is_expired +http.cookiejar.CookieJar.clear +http.cookiejar.FileCookieJar.__init__ +http.cookies.Morsel.setdefault +http.cookies.Morsel.update +http.server.HTTPServer.__init__ +imaplib.IMAP4_SSL.ssl +imaplib.IMAP4_stream.open +imghdr.what +importlib.abc.FileLoader.get_filename +importlib.abc.Loader.exec_module +importlib.abc.MetaPathFinder.find_spec +importlib.abc.PathEntryFinder.find_spec +importlib.machinery.BuiltinImporter.find_module +importlib.machinery.BuiltinImporter.find_spec +importlib.machinery.ExtensionFileLoader.get_filename +importlib.machinery.FrozenImporter.find_module +importlib.machinery.FrozenImporter.find_spec +importlib.machinery.FrozenImporter.module_repr +importlib.machinery.PathFinder.find_module +importlib.machinery.PathFinder.find_spec +importlib.machinery.PathFinder.invalidate_caches +importlib.machinery.SourceFileLoader.set_data +importlib.machinery.WindowsRegistryFinder.find_module +importlib.machinery.WindowsRegistryFinder.find_spec +importlib.util.spec_from_file_location +importlib.util.spec_from_loader +inspect.BlockFinder.tokeneater +inspect.Parameter.__init__ +inspect.Parameter.replace +inspect.Signature.__init__ +inspect.Signature.replace +inspect.formatargspec +inspect.formatargvalues +inspect.getabsfile +inspect.getinnerframes +inspect.getmodule +inspect.signature +io.BufferedRandom.truncate +io.BufferedReader.seek +io.BufferedReader.truncate +io.BufferedWriter.seek +io.BufferedWriter.truncate +io.BytesIO.readlines +io.FileIO.seek +io.StringIO.seek +io.StringIO.truncate +io.TextIOWrapper.truncate +ipaddress._BaseAddress.is_global +ipaddress._BaseAddress.is_link_local +ipaddress._BaseAddress.is_loopback +ipaddress._BaseAddress.is_multicast +ipaddress._BaseAddress.is_private +ipaddress._BaseAddress.is_reserved +ipaddress._BaseAddress.is_unspecified +ipaddress._BaseAddress.max_prefixlen +ipaddress._BaseAddress.packed +ipaddress._BaseNetwork.max_prefixlen +itertools.accumulate +itertools.chain.from_iterable +itertools.combinations +itertools.combinations_with_replacement +itertools.compress +itertools.count +itertools.dropwhile +itertools.filterfalse +itertools.permutations +itertools.starmap +itertools.takewhile +itertools.zip_longest +lib2to3.pygram.pattern_symbols +lib2to3.pygram.python_symbols +lib2to3.pytree.Base.children +lib2to3.pytree.Base.type +lib2to3.pytree.BasePattern.type +lib2to3.pytree.NegatedPattern.match +lib2to3.pytree.NegatedPattern.match_seq +locale.atof +locale.format +locale.format_string +locale.str +logging.Formatter.formatException +logging.Handler.addFilter +logging.Handler.removeFilter +logging.Logger.addFilter +logging.Logger.removeFilter +logging.LoggerAdapter.isEnabledFor +logging.LoggerAdapter.setLevel +logging.addLevelName +logging.disable +logging.getLevelName +logging.handlers.DatagramHandler.send +logging.handlers.NTEventLogHandler.__init__ +logging.handlers.SocketHandler.makeSocket +logging.handlers.SocketHandler.send +logging.handlers.SysLogHandler.__init__ +logging.makeLogRecord +logging.shutdown +mailbox.Babyl.__init__ +mailbox.MH.__init__ +mailbox.MMDF.__init__ +mailbox._mboxMMDF.get_bytes +mailbox._mboxMMDF.get_file +mailbox._mboxMMDF.get_string +mailbox.mbox.__init__ +mimetypes.read_mime_types +mmap.mmap.__iter__ +msvcrt +multiprocessing.Array +multiprocessing.Event +multiprocessing.JoinableQueue +multiprocessing.Queue +multiprocessing.SimpleQueue +multiprocessing.Value +multiprocessing.context.BaseContext.Event +multiprocessing.managers.BaseManager.shutdown +multiprocessing.managers.SyncManager.Event +multiprocessing.managers.SyncManager.Lock +multiprocessing.managers.SyncManager.Namespace +multiprocessing.managers.SyncManager.RLock +multiprocessing.pool.Pool.imap +multiprocessing.pool.Pool.imap_unordered +multiprocessing.pool.Pool.map +multiprocessing.pool.Pool.map_async +multiprocessing.pool.Pool.starmap +multiprocessing.pool.Pool.starmap_async +multiprocessing.queues.Queue.__init__ +multiprocessing.queues.Queue.put_nowait +multiprocessing.queues.SimpleQueue.__init__ +multiprocessing.queues.SimpleQueue.put +multiprocessing.set_executable +multiprocessing.synchronize.Barrier.__init__ +multiprocessing.synchronize.Condition.acquire +multiprocessing.synchronize.Condition.release +multiprocessing.synchronize.Event.__init__ +multiprocessing.synchronize.SemLock.acquire +multiprocessing.synchronize.SemLock.release +netrc.netrc.__init__ +nntplib._NNTPBase.starttls +ntpath.basename +ntpath.commonprefix +ntpath.dirname +ntpath.getatime +ntpath.getctime +ntpath.getmtime +ntpath.getsize +ntpath.isabs +ntpath.isdir +ntpath.normcase +ntpath.realpath +ntpath.samefile +ntpath.samestat +ntpath.split +ntpath.splitdrive +ntpath.splitext +numbers.Number.__hash__ +operator.methodcaller +optparse.HelpFormatter._format__Text +optparse.OptionParser.__init__ +optparse.Values.__getattr__ +optparse.Values.read_file +optparse.Values.read_module +os.EX_NOTFOUND +os.O_BINARY +os.O_EXLOCK +os.O_NOINHERIT +os.O_RANDOM +os.O_SEQUENTIAL +os.O_SHLOCK +os.O_SHORT_LIVED +os.O_TEMPORARY +os.O_TEXT +os.SCHED_SPORADIC +os.SF_MNOWAIT +os.SF_NODISKIO +os.SF_SYNC +os._Environ.setdefault +os.chflags +os.lchflags +os.lchmod +os.listxattr +os.path.basename +os.path.commonprefix +os.path.dirname +os.path.getatime +os.path.getctime +os.path.getmtime +os.path.getsize +os.path.isabs +os.path.isdir +os.path.join +os.path.normcase +os.path.samefile +os.path.samestat +os.path.split +os.path.splitdrive +os.path.splitext +os.plock +os.sched_param._asdict +os.sched_param._make +os.sched_param._replace +os.statvfs_result._asdict +os.statvfs_result._make +os.statvfs_result._replace +os.times_result._asdict +os.times_result._make +os.times_result._replace +os.uname_result._asdict +os.uname_result._make +os.uname_result._replace +os.waitid_result._asdict +os.waitid_result._make +os.waitid_result._replace +pdb.Pdb._print_lines +pdb.Pdb.setup +pickle.Pickler.persistent_id +pickle.Unpickler.find_class +pickle.Unpickler.persistent_load +pipes.Template.copy +pkgutil.ImpImporter.__init__ +plistlib.loads +poplib.POP3_SSL.stls +posix.EX_NOTFOUND +posix.sched_param._asdict +posix.sched_param._make +posix.sched_param._replace +posix.times_result._asdict +posix.times_result._make +posix.times_result._replace +posix.uname_result._asdict +posix.uname_result._make +posix.uname_result._replace +posix.waitid_result._asdict +posix.waitid_result._make +posix.waitid_result._replace +posixpath.basename +posixpath.commonprefix +posixpath.dirname +posixpath.getatime +posixpath.getctime +posixpath.getmtime +posixpath.getsize +posixpath.isabs +posixpath.isdir +posixpath.join +posixpath.normcase +posixpath.samefile +posixpath.samestat +posixpath.split +posixpath.splitdrive +posixpath.splitext +pstats.Stats.__init__ +pwd.getpwnam +pydoc.Doc.getdocloc +pydoc.HTMLDoc.docdata +pydoc.HTMLDoc.docproperty +pydoc.HTMLDoc.docroutine +pydoc.HTMLDoc.escape +pydoc.HTMLDoc.modpkglink +pydoc.HTMLDoc.repr +pydoc.TextDoc.docdata +pydoc.TextDoc.docmodule +pydoc.TextDoc.docother +pydoc.TextDoc.docproperty +pydoc.TextDoc.docroutine +pydoc.TextDoc.repr +pydoc.doc +pydoc.gui +pydoc.render_doc +pydoc.serve +random.Random.randrange +random.Random.triangular +random.SystemRandom.getstate +random.randrange +random.triangular +re.escape +runpy.run_path +sched.Event.__doc__ +select.EPOLL_RDHUP +select.KQ_EV_ADD +select.KQ_EV_CLEAR +select.KQ_EV_DELETE +select.KQ_EV_DISABLE +select.KQ_EV_ENABLE +select.KQ_EV_EOF +select.KQ_EV_ERROR +select.KQ_EV_FLAG1 +select.KQ_EV_ONESHOT +select.KQ_EV_SYSFLAGS +select.KQ_FILTER_AIO +select.KQ_FILTER_NETDEV +select.KQ_FILTER_PROC +select.KQ_FILTER_READ +select.KQ_FILTER_SIGNAL +select.KQ_FILTER_TIMER +select.KQ_FILTER_VNODE +select.KQ_FILTER_WRITE +select.KQ_NOTE_ATTRIB +select.KQ_NOTE_CHILD +select.KQ_NOTE_DELETE +select.KQ_NOTE_EXEC +select.KQ_NOTE_EXIT +select.KQ_NOTE_EXTEND +select.KQ_NOTE_FORK +select.KQ_NOTE_LINK +select.KQ_NOTE_LINKDOWN +select.KQ_NOTE_LINKINV +select.KQ_NOTE_LINKUP +select.KQ_NOTE_LOWAT +select.KQ_NOTE_PCTRLMASK +select.KQ_NOTE_PDATAMASK +select.KQ_NOTE_RENAME +select.KQ_NOTE_REVOKE +select.KQ_NOTE_TRACK +select.KQ_NOTE_TRACKERR +select.KQ_NOTE_WRITE +select.devpoll +select.kevent +select.kqueue +select.poll +selectors.DevpollSelector +selectors.KqueueSelector +shlex.shlex.__init__ +shlex.shlex.error_leader +shlex.shlex.sourcehook +shutil.register_unpack_format +signal.CTRL_BREAK_EVENT +signal.CTRL_C_EVENT +signal.SIGBREAK +signal.SIGEMT +signal.SIGINFO +site.getsitepackages +site.getuserbase +site.getusersitepackages +smtpd.MailmanProxy.process_message +smtpd.PureProxy.process_message +smtplib.SMTP.send_message +socket.AF_AAL5 +socket.AF_BLUETOOTH +socket.AF_DECnet +socket.AF_LINK +socket.AF_SYSTEM +socket.AI_DEFAULT +socket.AI_MASK +socket.AI_V4MAPPED_CFG +socket.BDADDR_ANY +socket.BDADDR_LOCAL +socket.BTPROTO_HCI +socket.BTPROTO_L2CAP +socket.BTPROTO_RFCOMM +socket.BTPROTO_SCO +socket.EAIEAI_ADDRFAMILY +socket.EAI_BADHINTS +socket.EAI_MAX +socket.EAI_PROTOCOL +socket.EINTR +socket.HCI_DATA_DIR +socket.HCI_FILTER +socket.HCI_TIME_STAMP +socket.IPPROTO_BIP +socket.IPPROTO_EON +socket.IPPROTO_GGP +socket.IPPROTO_HELLO +socket.IPPROTO_IPCOMP +socket.IPPROTO_IPV4 +socket.IPPROTO_MAX +socket.IPPROTO_MOBILE +socket.IPPROTO_ND +socket.IPPROTO_VRRP +socket.IPPROTO_XTP +socket.IPV6_USE_MIN_MTU +socket.IPX_TYPE +socket.IP_RECVDSTADDR +socket.LOCAL_PEERCRED +socket.MSG_BCAST +socket.MSG_BTAG +socket.MSG_EOF +socket.MSG_ETAG +socket.MSG_MCAST +socket.MSG_NOTIFICATION +socket.NETLINK_ARPD +socket.NETLINK_ROUTE6 +socket.NETLINK_SKIP +socket.NETLINK_TAPBASE +socket.NETLINK_TCPDIAG +socket.NETLINK_W1 +socket.RDS_CANCEL_SENT_TO +socket.RDS_CMSG_RDMA_ARGS +socket.RDS_CMSG_RDMA_DEST +socket.RDS_CMSG_RDMA_MAP +socket.RDS_CMSG_RDMA_STATUS +socket.RDS_CMSG_RDMA_UPDATE +socket.RDS_CONG_MONITOR +socket.RDS_FREE_MR +socket.RDS_GET_MR +socket.RDS_GET_MR_FOR_DEST +socket.RDS_RDMA_DONTWAIT +socket.RDS_RDMA_FENCE +socket.RDS_RDMA_INVALIDATE +socket.RDS_RDMA_NOTIFY_ME +socket.RDS_RDMA_READWRITE +socket.RDS_RDMA_SILENT +socket.RDS_RDMA_USE_ONCE +socket.RDS_RECVERR +socket.SCM_CREDS +socket.SOL_ATALK +socket.SOL_AX25 +socket.SOL_HCI +socket.SOL_IPX +socket.SOL_NETROM +socket.SOL_ROSE +socket.SO_EXCLUSIVEADDRUSE +socket.SO_SETFIB +socket.SO_USELOOPBACK +socket.create_connection +socket.socketpair +socketserver.BaseServer.fileno +socketserver.BaseServer.get_request +socketserver.BaseServer.server_bind +spwd.getspnam +spwd.struct_spwd._asdict +spwd.struct_spwd._make +spwd.struct_spwd._replace +sqlite3.Row.__len__ +sqlite3.dbapi2.Row.__len__ +sqlite3.dbapi2.register_adapters_and_converters +sqlite3.dbapi2.version_info +sqlite3.register_adapters_and_converters +sqlite3.version_info +sre_constants.error.__init__ +sre_parse.NIC +sre_parse.SubPattern.__init__ +sre_parse.fix_flags +sre_parse.parse +ssl.PROTOCOL_SSLv2 +ssl.PROTOCOL_SSLv3 +ssl.RAND_add +ssl.RAND_egd +ssl.SSLContext.load_cert_chain +ssl.SSLContext.load_dh_params +ssl.SSLContext.set_alpn_protocols +ssl.SSLContext.set_ciphers +ssl.SSLContext.set_ecdh_curve +ssl.SSLContext.set_npn_protocols +ssl.SSLObject.write +ssl.SSLSocket.connect +ssl.SSLSocket.connect_ex +ssl.SSLSocket.do_handshake +ssl.SSLSocket.recv +ssl.SSLSocket.recv_into +ssl.SSLSocket.recvfrom +ssl.SSLSocket.recvfrom_into +ssl.SSLSocket.sendto +ssl.SSLSocket.write +ssl._ASN1Object.__new__ +statistics.median_grouped +string.capwords +subprocess.Popen.send_signal +subprocess.call +sunau.Au_write.getmark +sunau.Au_write.getmarkers +sunau.Au_write.setcomptype +sunau.Au_write.setmark +sys.gettotalrefcount +sys.getwindowsversion +sys.implementation +sys.last_traceback +sys.last_type +sys.last_value +sys.ps1 +sys.ps2 +sys.settscdump +sys.tracebacklimit +sysconfig.is_python_build +sysconfig.parse_config_h +tarfile.TarFile.__init__ +tarfile.TarFile.errors +tarfile.TarFile.tarinfo +tempfile.SpooledTemporaryFile.__next__ +tempfile.SpooledTemporaryFile.readable +tempfile.SpooledTemporaryFile.seekable +tempfile.SpooledTemporaryFile.writable +tempfile.SpooledTemporaryFile.writelines +textwrap.TextWrapper.x +textwrap.indent +textwrap.wrap +threading.BoundedSemaphore.__enter__ +threading.BoundedSemaphore.acquire +threading.Condition.acquire +threading.Condition.release +threading.Lock +threading.Semaphore.__enter__ +threading.Semaphore.acquire +threading.Thread.__init__ +time.CLOCK_HIGHRES +timeit.main +traceback.FrameSummary.__init__ +traceback.TracebackException.__init__ +traceback.TracebackException.from_exception +tracemalloc.Snapshot.load +types.GetSetDescriptorType.__get__ +types.GetSetDescriptorType.__set__ +types.MemberDescriptorType.__get__ +types.MemberDescriptorType.__set__ +types.SimpleNamespace.__init__ +types.coroutine +types.new_class +types.prepare_class +typing.AwaitableGenerator +typing.Generic +typing.IO.__iter__ +typing.IO.__next__ +typing.IO.closed +typing.Match +typing.NamedTuple._asdict +typing.NamedTuple._make +typing.NamedTuple._replace +typing.Pattern +typing.TypeAlias +typing.cast +typing.type_check_only +unittest.TestCase.assertAlmostEqual +unittest.TestCase.assertDictContainsSubset +unittest.TestCase.assertNotAlmostEqual +unittest.TestCase.assertSequenceEqual +unittest.TestLoader.loadTestsFromModule +unittest.TestResult.addSubTest +unittest.TestRunner +unittest.TestSuite.run +unittest.case.TestCase.assertAlmostEqual +unittest.case.TestCase.assertDictContainsSubset +unittest.case.TestCase.assertNotAlmostEqual +unittest.case.TestCase.assertSequenceEqual +unittest.case.expectedFailure +unittest.expectedFailure +unittest.loader.TestLoader.loadTestsFromModule +unittest.main +unittest.removeHandler +unittest.result.TestResult.addSubTest +unittest.runner.TestRunner +unittest.signals.removeHandler +unittest.suite.TestSuite.run +urllib.parse.quote +urllib.parse.quote_plus +urllib.request.BaseHandler.http_error_nnn +urllib.request.HTTPBasicAuthHandler.http_error_401 +urllib.request.HTTPDigestAuthHandler.http_error_401 +urllib.request.HTTPRedirectHandler.http_error_301 +urllib.request.HTTPRedirectHandler.http_error_302 +urllib.request.HTTPRedirectHandler.http_error_303 +urllib.request.HTTPRedirectHandler.http_error_307 +urllib.request.HTTPRedirectHandler.redirect_request +urllib.request.OpenerDirector.open +urllib.request.ProxyBasicAuthHandler.http_error_407 +urllib.request.ProxyDigestAuthHandler.http_error_407 +urllib.request.pathname2url +urllib.request.proxy_bypass +urllib.request.url2pathname +urllib.response.addbase.__next__ +urllib.response.addbase.fileno +urllib.response.addbase.flush +urllib.response.addbase.isatty +urllib.response.addbase.read +urllib.response.addbase.readable +urllib.response.addbase.readline +urllib.response.addbase.readlines +urllib.response.addbase.seek +urllib.response.addbase.seekable +urllib.response.addbase.tell +urllib.response.addbase.truncate +urllib.response.addbase.writable +urllib.response.addbase.write +urllib.response.addbase.writelines +urllib.robotparser.RobotFileParser.can_fetch +weakref.CallableProxyType.__getattr__ +weakref.ProxyType.__getattr__ +weakref.ReferenceType.__call__ +weakref.WeakKeyDictionary.__init__ +weakref.WeakKeyDictionary.get +weakref.WeakKeyDictionary.pop +weakref.WeakKeyDictionary.setdefault +weakref.WeakKeyDictionary.update +weakref.WeakValueDictionary.get +weakref.WeakValueDictionary.pop +weakref.WeakValueDictionary.setdefault +webbrowser.Mozilla.raise_opts +webbrowser.UnixBrowser.raise_opts +webbrowser.UnixBrowser.remote_action +webbrowser.UnixBrowser.remote_action_newtab +webbrowser.UnixBrowser.remote_action_newwin +winsound +wsgiref.types +wsgiref.util.FileWrapper.__init__ +wsgiref.util.FileWrapper.close +xml.etree.ElementPath._SelectorContext.parent_map +xml.etree.ElementTree.Element.__bool__ +xml.etree.ElementTree.Element.copy +xml.etree.ElementTree.TreeBuilder.start +xml.etree.cElementTree.Element.__bool__ +xml.etree.cElementTree.Element.copy +xml.etree.cElementTree.TreeBuilder.start +xml.sax.xmlreader.AttributesImpl.has_key +zipfile.ZipExtFile.read +zipfile.ZipExtFile.readline +zipfile.ZipFile.extract +zipfile.ZipFile.fp +zlib.compressobj