diff --git a/.travis.yml b/.travis.yml index 3c595d768833..3a24eb683fca 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 9535cac066df..180fecc97807 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 -[pytype](https://github.com/google/pytype/). - -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. +the repo. Note that it can be useful to enable Travis CI on your own fork of +typeshed. -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. +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. -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. + +### mypy_test.py -For mypy, if you are in the typeshed repo that is submodule of the +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 000000000000..4937321b02da --- /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 000000000000..a0d6dbbcdd36 --- /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 000000000000..c80f09a9ef49 --- /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 000000000000..249a94a0e7da --- /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 000000000000..ec63cb14ec1a --- /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 000000000000..287d5bc0a7bd --- /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